def _spawn_sensor_process(self, sensor):
        """
        Spawn a new process for the provided sensor.

        New process uses isolated Python binary from a virtual environment
        belonging to the sensor pack.
        """
        sensor_id = self._get_sensor_id(sensor=sensor)
        pack_ref = sensor["pack"]

        virtualenv_path = get_sandbox_virtualenv_path(pack=pack_ref)
        python_path = get_sandbox_python_binary_path(pack=pack_ref)

        if virtualenv_path and not os.path.isdir(virtualenv_path):
            format_values = {"pack": sensor["pack"], "virtualenv_path": virtualenv_path}
            msg = PACK_VIRTUALENV_DOESNT_EXIST % format_values
            raise Exception(msg)

        args = self._get_args_for_wrapper_script(
            python_binary=python_path, sensor=sensor
        )

        if self._enable_common_pack_libs:
            pack_common_libs_path = get_pack_common_libs_path_for_pack_ref(
                pack_ref=pack_ref
            )
        else:
            pack_common_libs_path = None

        env = os.environ.copy()

        sandbox_python_path = get_sandbox_python_path(
            inherit_from_parent=True, inherit_parent_virtualenv=True
        )

        if self._enable_common_pack_libs and pack_common_libs_path:
            env["PYTHONPATH"] = pack_common_libs_path + ":" + sandbox_python_path
        else:
            env["PYTHONPATH"] = sandbox_python_path

        if self._create_token:
            # Include full api URL and API token specific to that sensor
            LOG.debug(
                "Creating temporary auth token for sensor %s" % (sensor["class_name"])
            )

            ttl = cfg.CONF.auth.service_token_ttl
            metadata = {
                "service": "sensors_container",
                "sensor_path": sensor["file_path"],
                "sensor_class": sensor["class_name"],
            }
            temporary_token = create_token(
                username="sensors_container", ttl=ttl, metadata=metadata, service=True
            )

            env[API_URL_ENV_VARIABLE_NAME] = get_full_public_api_url()
            env[AUTH_TOKEN_ENV_VARIABLE_NAME] = temporary_token.token

            # TODO 1: Purge temporary token when service stops or sensor process dies
            # TODO 2: Store metadata (wrapper process id) with the token and delete
            # tokens for old, dead processes on startup

        cmd = " ".join(args)
        LOG.debug('Running sensor subprocess (cmd="%s")', cmd)

        # TODO: Intercept stdout and stderr for aggregated logging purposes
        try:
            process = subprocess.Popen(
                args=args,
                stdin=None,
                stdout=None,
                stderr=None,
                shell=False,
                env=env,
                preexec_fn=on_parent_exit("SIGTERM"),
            )
        except Exception as e:
            cmd = " ".join(args)
            message = 'Failed to spawn process for sensor %s ("%s"): %s' % (
                sensor_id,
                cmd,
                six.text_type(e),
            )
            raise Exception(message)

        self._processes[sensor_id] = process
        self._sensors[sensor_id] = sensor
        self._sensor_start_times[sensor_id] = int(time.time())

        self._dispatch_trigger_for_sensor_spawn(sensor=sensor, process=process, cmd=cmd)

        return process

        Spawn a new process for the provided sensor.

        New process uses isolated Python binary from a virtual environment
        belonging to the sensor pack.
        
st2reactor/st2reactor/container/process_container.py