final OutputEventListener listener = Mock(OutputEventListener.class)

        loggingManager.addOutputEventListener(listener)

        when:
        loggingManager.start();

        then:
        1 * loggingRouter.addOutputEventListener(listener)

        when:
        loggingManager.stop()

        then:
        loggingManager.removeOutputEventListener(listener)

            loggingOutput.removeStandardErrorListener(listener);
        }
    }

    @Override
    public void addOutputEventListener(OutputEventListener listener) {
        if (outputEventListeners.add(listener) && started) {
            loggingOutput.addOutputEventListener(listener);
        }
    }

    @Override
    public void removeOutputEventListener(OutputEventListener listener) {

        LogEvent ignored = event('ignored', LogLevel.DEBUG)
        LogEvent event = event('message', LogLevel.INFO)

        when:
        renderer.configure(LogLevel.INFO)
        renderer.addOutputEventListener(listener)
        renderer.onOutput(ignored)
        renderer.onOutput(event)

        then:
        1 * listener.onOutput({ it instanceof LogLevelChangeEvent && it.newLogLevel == LogLevel.INFO })

    def configuresLoggingWhileActionIsExecuting() {
        when:
        executer.execute(action, parameters, buildRequestContext)

        then:
        1 * loggingManager.addOutputEventListener(!null)
        1 * loggingManager.start()
        1 * target.execute(action, parameters, buildRequestContext)
        1 * loggingManager.stop()
    }

    def restoresLoggingWhenActionFails() {

        ProgressListenerVersion1 progressListener = actionParameters.getProgressListener();
        OutputEventListenerAdapter listener = new OutputEventListenerAdapter(progressListener);
        loggingManager.addOutputEventListener(listener);
        loggingManager.setLevelInternal(actionParameters.getBuildLogLevel());
        loggingManager.start();
        try {
            return delegate.execute(action, parameters, buildRequestContext);

                }
            };
            LOGGER.debug(DaemonMessages.ABOUT_TO_START_RELAYING_LOGS);
            loggingOutput.addOutputEventListener(listener);
        }

        public void submit(OutputEvent event) {
            eventQueue.add(event);
        }

        @Override
        public void run() {
            try {

     */
    void addStandardErrorListener(OutputStream outputStream);

    /**
     * Adds the given listener as a logging destination.
     */
    @UsedByScanPlugin
    void addOutputEventListener(OutputEventListener listener);

    /**
     * Adds the given listener.
     */
    @UsedByScanPlugin
    void removeOutputEventListener(OutputEventListener listener);

    /**

                    }
                    loggingOutput = objects.newInstance(InternalServices).loggingOutput
                    println("ADDING " + this + " TO " + loggingOutput)
                    loggingOutput.addOutputEventListener(this)
                }

                @Override
                synchronized void close() {
                    println("REMOVING " + this + " FROM " + loggingOutput)

        listenerManager.addListener(stopSessionScopeWorkers);
        this.logLevelChangeEventListener = new LogLevelChangeEventListener();
        loggingManager.addOutputEventListener(logLevelChangeEventListener);
        this.currentLogLevel = loggingManager.getLevel();
        this.memoryManager = memoryManager;

        WorkerLoggingProtocol workerLoggingProtocol = connection.addOutgoing(WorkerLoggingProtocol.class);
        workerLogEventListener.setWorkerLoggingProtocol(workerLoggingProtocol);
        loggingManager.addOutputEventListener(workerLogEventListener);
    }

    private void configureWorkerJvmMemoryInfoEvents(WorkerServices services, ObjectConnection connection) {