code: def _configure_interrupt(self, function_name, timeout, container, is_debugging):
          
  
          def timer_handler():
              # NOTE: This handler runs in a separate thread. So don't try to mutate any non-thread-safe data structures
              LOG.info("Function '%s' timed out after %d seconds", function_name, timeout)
              self._container_manager.stop(container)
  
          def signal_handler(sig, frame):
              # NOTE: This handler runs in a separate thread. So don't try to mutate any non-thread-safe data structures
              LOG.info("Execution of function %s was interrupted", function_name)
              self._container_manager.stop(container)
  
          if is_debugging:
              LOG.debug("Setting up SIGTERM interrupt handler")
              signal.signal(signal.SIGTERM, signal_handler)
          else:
              # Start a timer, we'll use this to abort the function if it runs beyond the specified timeout
              LOG.debug("Starting a timer for %s seconds for function '%s'", timeout, function_name)
              timer = threading.Timer(timeout, timer_handler, ())
              timer.start()
              return timer
docs: When a Lambda function is executing, we setup certain interrupt handlers to stop the execution.
          Usually, we setup a function timeout interrupt to kill the container after timeout expires. If debugging though,
          we don't enforce a timeout. But we setup a SIGINT interrupt to catch Ctrl+C and terminate the container.
  
          :param string function_name: Name of the function we are running
          :param integer timeout: Timeout in seconds
          :param samcli.local.docker.container.Container container: Instance of a container to terminate
          :param bool is_debugging: Are we debugging?
          :return threading.Timer: Timer object, if we setup a timer. None otherwise