Examples with StandardOutputListener org.gradle.api.logging.StandardOutputListener used on opensource projects

Example 1 with StandardOutputListener

use of org.gradle.api.logging.StandardOutputListener in project gradle by gradle.

the class DefaultLoggingManager method stop.

@Override
public DefaultLoggingManager stop() {
    try {
        CompositeStoppable.stoppable(slf4jLoggingSystem, javaUtilLoggingSystem, stdOutLoggingSystem, stdErrLoggingSystem).stop();
        for (StandardOutputListener stdoutListener : stdoutListeners) {
            loggingOutput.removeStandardOutputListener(stdoutListener);
        }
        for (StandardOutputListener stderrListener : stderrListeners) {
            loggingOutput.removeStandardErrorListener(stderrListener);
        }
        for (OutputEventListener listener : outputEventListeners) {
            loggingOutput.removeOutputEventListener(listener);
        }
        loggingRouter.stop();
    } finally {
        started = false;
    }
    return this;
}

Example 2 with StandardOutputListener

use of org.gradle.api.logging.StandardOutputListener in project gradle by gradle.

the class DefaultGradleLauncherFactory method doNewInstance.

private DefaultGradleLauncher doNewInstance(StartParameter startParameter, GradleLauncher parent, BuildCancellationToken cancellationToken, BuildRequestMetaData requestMetaData, BuildEventConsumer buildEventConsumer, final BuildSessionScopeServices sessionScopeServices, List<?> servicesToStop) {
    BuildScopeServices serviceRegistry = BuildScopeServices.forSession(sessionScopeServices);
    serviceRegistry.add(BuildRequestMetaData.class, requestMetaData);
    serviceRegistry.add(BuildClientMetaData.class, requestMetaData.getClient());
    serviceRegistry.add(BuildEventConsumer.class, buildEventConsumer);
    serviceRegistry.add(BuildCancellationToken.class, cancellationToken);
    NestedBuildFactoryImpl nestedBuildFactory = new NestedBuildFactoryImpl(sessionScopeServices);
    serviceRegistry.add(NestedBuildFactory.class, nestedBuildFactory);
    ListenerManager listenerManager = serviceRegistry.get(ListenerManager.class);
    LoggingManagerInternal loggingManager = serviceRegistry.newInstance(LoggingManagerInternal.class);
    loggingManager.setLevelInternal(startParameter.getLogLevel());
    //this hooks up the ListenerManager and LoggingConfigurer so you can call Gradle.addListener() with a StandardOutputListener.
    loggingManager.addStandardOutputListener(listenerManager.getBroadcaster(StandardOutputListener.class));
    loggingManager.addStandardErrorListener(listenerManager.getBroadcaster(StandardOutputListener.class));
    LoggerProvider loggerProvider = (parent == null) ? buildProgressLogger : LoggerProvider.NO_OP;
    listenerManager.useLogger(new TaskExecutionLogger(serviceRegistry.get(ProgressLoggerFactory.class), loggerProvider));
    if (parent == null) {
        listenerManager.useLogger(new BuildLogger(Logging.getLogger(BuildLogger.class), serviceRegistry.get(StyledTextOutputFactory.class), startParameter, requestMetaData));
    }
    if (startParameter.isBuildCacheEnabled()) {
        listenerManager.addListener(serviceRegistry.get(TaskExecutionStatisticsEventAdapter.class));
        listenerManager.addListener(new CacheStatisticsReporter(serviceRegistry.get(StyledTextOutputFactory.class)));
    }
    listenerManager.addListener(serviceRegistry.get(ProfileEventAdapter.class));
    if (startParameter.isProfile()) {
        listenerManager.addListener(new ReportGeneratingProfileListener(serviceRegistry.get(StyledTextOutputFactory.class)));
    }
    BuildScanRequest buildScanRequest = serviceRegistry.get(BuildScanRequest.class);
    if (startParameter.isBuildScan()) {
        if (!startParameter.getSystemPropertiesArgs().containsKey("scan")) {
            startParameter.getSystemPropertiesArgs().put("scan", "true");
        }
        buildScanRequest.markRequested();
        listenerManager.addListener(new BuildScanRequestListener());
    }
    if (startParameter.isNoBuildScan()) {
        if (!startParameter.getSystemPropertiesArgs().containsKey("scan")) {
            startParameter.getSystemPropertiesArgs().put("scan", "false");
        }
        buildScanRequest.markDisabled();
    }
    ScriptUsageLocationReporter usageLocationReporter = new ScriptUsageLocationReporter();
    listenerManager.addListener(usageLocationReporter);
    BuildOutputCleanupListener buildOutputCleanupListener = serviceRegistry.get(BuildOutputCleanupListener.class);
    listenerManager.addListener(buildOutputCleanupListener);
    ShowStacktrace showStacktrace = startParameter.getShowStacktrace();
    switch(showStacktrace) {
        case ALWAYS:
        case ALWAYS_FULL:
            LoggingDeprecatedFeatureHandler.setTraceLoggingEnabled(true);
            break;
        default:
            LoggingDeprecatedFeatureHandler.setTraceLoggingEnabled(false);
    }
    DeprecationLogger.useLocationReporter(usageLocationReporter);
    SettingsLoaderFactory settingsLoaderFactory = serviceRegistry.get(SettingsLoaderFactory.class);
    SettingsLoader settingsLoader = parent != null ? settingsLoaderFactory.forNestedBuild() : settingsLoaderFactory.forTopLevelBuild();
    GradleInternal parentBuild = parent == null ? null : parent.getGradle();
    GradleInternal gradle = serviceRegistry.get(Instantiator.class).newInstance(DefaultGradle.class, parentBuild, startParameter, serviceRegistry.get(ServiceRegistryFactory.class));
    DefaultGradleLauncher gradleLauncher = new DefaultGradleLauncher(gradle, serviceRegistry.get(InitScriptHandler.class), settingsLoader, serviceRegistry.get(BuildConfigurer.class), serviceRegistry.get(ExceptionAnalyser.class), loggingManager, gradle.getBuildListenerBroadcaster(), listenerManager.getBroadcaster(ModelConfigurationListener.class), listenerManager.getBroadcaster(BuildCompletionListener.class), serviceRegistry.get(BuildOperationExecutor.class), gradle.getServices().get(BuildConfigurationActionExecuter.class), gradle.getServices().get(BuildExecuter.class), serviceRegistry, servicesToStop);
    nestedBuildFactory.setParent(gradleLauncher);
    return gradleLauncher;
}

Example 3 with StandardOutputListener

use of org.gradle.api.logging.StandardOutputListener in project gradle by gradle.

the class DefaultLoggingManager method start.

@Override
public DefaultLoggingManager start() {
    started = true;
    if (enableStdOutListeners) {
        loggingRouter.loggingRouter.enableUserStandardOutputListeners();
    }
    for (StandardOutputListener stdoutListener : stdoutListeners) {
        loggingOutput.addStandardOutputListener(stdoutListener);
    }
    for (StandardOutputListener stderrListener : stderrListeners) {
        loggingOutput.addStandardErrorListener(stderrListener);
    }
    for (OutputEventListener outputEventListener : outputEventListeners) {
        loggingOutput.addOutputEventListener(outputEventListener);
    }
    loggingRouter.start();
    slf4jLoggingSystem.enableCapture();
    slf4jLoggingSystem.start();
    javaUtilLoggingSystem.start();
    stdOutLoggingSystem.start();
    stdErrLoggingSystem.start();
    return this;
}

Example 4 with StandardOutputListener

use of org.gradle.api.logging.StandardOutputListener in project gradle by gradle.

the class OutputEventRenderer method enableUserStandardOutputListeners.

@Override
public void enableUserStandardOutputListeners() {
    // Then, a pipeline can be added for each listener as required
    synchronized (lock) {
        if (userStdoutListeners == null) {
            userStdoutListeners = new ListenerBroadcast<StandardOutputListener>(StandardOutputListener.class);
            userStderrListeners = new ListenerBroadcast<StandardOutputListener>(StandardOutputListener.class);
            final OutputEventListener stdOutChain = new StyledTextOutputBackedRenderer(new StreamingStyledTextOutput(userStdoutListeners.getSource()));
            final OutputEventListener stdErrChain = new StyledTextOutputBackedRenderer(new StreamingStyledTextOutput(userStderrListeners.getSource()));
            userListenerChain = new BuildLogLevelFilterRenderer(new ProgressLogEventGenerator(new OutputEventListener() {

                @Override
                public void onOutput(OutputEvent event) {
                    // Do not forward events for rendering when there are no listeners to receive
                    if (event instanceof LogLevelChangeEvent) {
                        stdOutChain.onOutput(event);
                        stdErrChain.onOutput(event);
                    } else if (event.getLogLevel() == LogLevel.ERROR && !userStderrListeners.isEmpty() && event instanceof RenderableOutputEvent) {
                        stdErrChain.onOutput(event);
                    } else if (event.getLogLevel() != LogLevel.ERROR && !userStdoutListeners.isEmpty() && event instanceof RenderableOutputEvent) {
                        stdOutChain.onOutput(event);
                    }
                }
            }));
            addChain(userListenerChain);
        }
    }
}