* However, the reverse is not true:
     * events broadcast in the parent are not received by the listeners in the children.
     * The child inherits the loggers of its parent, though these can be replaced.
     *
     * @return The child
     */
    ScopedListenerManager createChild(Class<? extends Scope> scope);

func Logger() Interface {
	impl := logger.Load()
	if impl == nil {
		return nil
	}
	return *impl.(*Interface)
}

// Getenv calls Logger().Getenv, if a logger has been set.
func Getenv(name string) {
	if log := Logger(); log != nil {
		log.Getenv(name)
	}
}

// Open calls Logger().Open, if a logger has been set.
func Open(name string) {
	if log := Logger(); log != nil {
		log.Open(name)
	}
}

  ) {
    val logger = Logger.getLogger(logger)
    if (configuredLoggers.add(logger)) {
      logger.useParentHandlers = false
      // log based on levels at startup to avoid logging each frame
      logger.level =
        when {
          Log.isLoggable(tag, Log.DEBUG) -> Level.FINE
          Log.isLoggable(tag, Log.INFO) -> Level.INFO
          else -> Level.WARNING
        }
      logger.addHandler(AndroidLogHandler)

        loggerFactory = LoggerFactory.getILoggerFactory();
    }

    public Logger getLoggerForComponent(String role) {
        return new Slf4jLogger(loggerFactory.getLogger(role));
    }

    /**
     * The logger name for a component with a non-null hint is <code>role.hint</code>.
     * <b>Warning</b>: this does not conform to logger name as class name convention.

            }
        }
        return event;
    }

    @PluginFactory
    public static ErrorToWarnRewritePolicy createPolicy(@PluginAttribute("loggers") final String loggerNamePrefix) {
        final String[] loggerNames = loggerNamePrefix != null
                ? Arrays.stream(loggerNamePrefix.split(",")).map(String::trim).filter(s -> s.length() > 0).toArray(n -> new String[n])

        implements WagonManager {

    // NOTE: This must use a different field name than in the super class or IoC has no chance to inject the loggers
    @Inject
    private Logger log;

    @Inject
    private LegacySupport legacySupport;

    @Inject
    private SettingsDecrypter settingsDecrypter;

    @Inject
    private MirrorSelector mirrorSelector;

    @Inject

            }
        }
    }

    @Override
    public void output(TestDescriptorInternal testDescriptor, TestOutputEvent event) {
    }

    /**
     * Completes and clears registered progress loggers even if test worker crashed.
     */
    public void completeAll() {
        for (ProgressLogger progressLogger : testWorkerProgressLoggers.values()) {
            progressLogger.completed();
        }

    /**
     * Uses the given object as a logger. Each listener class has exactly one logger associated with it. Any existing
     * logger for the listener class is discarded. Loggers are otherwise treated the same way as listeners.
     *
     * @param logger The new logger to use.
     */
    void useLogger(Object logger);

* Defining machine-specific details (e.g., JDK locations)
* Registering build listeners (e.g., external tools that wish to listen to Gradle events might find this helpful)
* Registering loggers (e.g., customize how Gradle logs the events that it generates)

One main <<sharing_build_logic_between_subprojects.adoc#sec:using_buildsrc,limitation of init scripts>> is that they cannot access classes in the `buildSrc` project.

    private final StandardOutputRedirector.OutputListener stdErrListener = Mock()
    private final Logger logger1 = Logger.getLogger("")
    private final Logger logger2 = Logger.getLogger("hello")
    private final Logger logger3 = Logger.getLogger("hello.world")
    private static String savedJULConfigClassProperty = null;

    public static class DummyFormatter extends Formatter {