This is an automated email from the ASF dual-hosted git repository. davsclaus pushed a commit to branch CAMEL-26937-cli-startup in repository https://gitbox.apache.org/repos/asf/camel.git
commit 01fa59bfe77e6b1dd84b8f102c606b803a18e4b1 Author: Claus Ibsen <[email protected]> AuthorDate: Sun Nov 15 13:58:00 2026 +0100 CAMEL-26937: camel-jbang - the short commands start without log4j, and print without a JLine terminal when piped - The CLI has an SLF4J provider of its own (CliLoggerProvider, installed by the main method of the launcher and of JBang): its loggers log nothing until the CLI configures the logging (RuntimeUtil.configureLog, camel infra run), and then log with log4j. A command that turns the logging off, such as camel ps, get or doc, no longer starts log4j only because a class of Camel creates a static logger. Log4j already logged nothing until the CLI configured it (CAMEL-26429), so the commands log as before. - Without a terminal a command leaves out the ANSI colors of printColored itself, as the console would, instead of asking the console, which builds a JLine system terminal to find that out. -Djansi.mode still goes to the console. Measured with the launcher on JDK 25, warm CDS, best of 7: camel ps 237 -> 140 ms, get route 259 -> 170 ms, doc timer 245 -> 150 ms, camel log (piped) 439 -> 347 ms. The debug log of camel run is the same, line for line. Co-Authored-By: Claude Opus 5.5 <[email protected]> Signed-off-by: Claus Ibsen <[email protected]> --- .../dsl/jbang/core/commands/CamelCommand.java | 31 ++- .../dsl/jbang/core/commands/CamelJBangMain.java | 6 + .../dsl/jbang/core/commands/infra/InfraRun.java | 2 + .../core/commands/CamelCommandColorsTest.java | 77 ++++++++ .../dsl/jbang/run/common/CliLoggerProvider.java | 218 +++++++++++++++++++++ .../camel/dsl/jbang/run/common/CliLogging.java | 93 +++++++++ .../camel/dsl/jbang/run/common/RuntimeUtil.java | 8 +- .../jbang/run/common/CliLoggerProviderTest.java | 119 +++++++++++ .../camel/dsl/jbang/run/common/CliLoggingTest.java | 83 ++++++++ .../camel/dsl/jbang/launcher/CamelLauncher.java | 4 + .../jbang/launcher/LauncherStartupLoggingTest.java | 11 ++ 11 files changed, 647 insertions(+), 5 deletions(-) diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java index b504f74fcd17..c09999140527 100644 --- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java +++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java @@ -23,6 +23,7 @@ import java.util.List; import java.util.Optional; import java.util.Properties; import java.util.Set; +import java.util.regex.Pattern; import org.aesh.command.Command; import org.aesh.command.CommandResult; @@ -46,6 +47,9 @@ import org.jline.jansi.AnsiMode; public abstract class CamelCommand implements Command<CommandInvocation>, CommandTree.ParsedCommandAware { + // an ANSI escape code (CSI), such as the colors of the Jansi Ansi builder + private static final Pattern ANSI_CODE = Pattern.compile("\\x1B\\[[0-9;:?]*[ -/]*[@-~]"); + // the model of the options of this command, and the tree it runs in (set when the command line is built) private ProcessedCommand<?, ?> processedCommand; private CommandTree tree; @@ -327,7 +331,9 @@ public abstract class CamelCommand implements Command<CommandInvocation>, Comman * CLI that runs the command in its own JVM and keeps its output (see {@link CliRunner}). */ protected void printColored(Object text) { - if (printsToConsole()) { + if (printsToConsole() && stripsColorsItself()) { + printer().print(withoutColors(text)); + } else if (printsToConsole()) { AnsiConsole.out().print(text); } else { printer().print(String.valueOf(text)); @@ -338,7 +344,9 @@ public abstract class CamelCommand implements Command<CommandInvocation>, Comman * Prints a line with colors (ANSI escape codes), see {@link #printColored(Object)}. */ protected void printlnColored(Object text) { - if (printsToConsole()) { + if (printsToConsole() && stripsColorsItself()) { + printer().println(withoutColors(text)); + } else if (printsToConsole()) { AnsiConsole.out().println(text); } else { printer().println(String.valueOf(text)); @@ -352,7 +360,24 @@ public abstract class CamelCommand implements Command<CommandInvocation>, Comman * (CAMEL-26911). */ protected boolean colorsStripped() { - return printsToConsole() && AnsiConsole.out().getMode() == AnsiMode.Strip; + return printsToConsole() && (stripsColorsItself() || AnsiConsole.out().getMode() == AnsiMode.Strip); + } + + /** + * Whether the command leaves out the colors itself, instead of the console: when the output is not a terminal, as + * the console would leave them out then too, and finding that out builds a JLine terminal, which costs more than + * most commands take to print (CAMEL-26937). Unless the console is told how to print the colors + * ({@code -Djansi.mode}). + */ + private static boolean stripsColorsItself() { + return !EnvironmentHelper.hasTerminal() + && System.getProperty(AnsiConsole.JANSI_MODE) == null + && System.getProperty(AnsiConsole.JANSI_OUT_MODE) == null; + } + + // the text without the ANSI escape codes of its colors + private static String withoutColors(Object text) { + return ANSI_CODE.matcher(String.valueOf(text)).replaceAll(""); } /** diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java index 16b1e577be84..4293e0b23a0d 100644 --- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java +++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java @@ -80,6 +80,7 @@ import org.apache.camel.dsl.jbang.core.common.JsonOutput; import org.apache.camel.dsl.jbang.core.common.Plugin; import org.apache.camel.dsl.jbang.core.common.PluginHelper; import org.apache.camel.dsl.jbang.core.common.PluginType; +import org.apache.camel.dsl.jbang.run.common.CliLogging; import org.apache.camel.dsl.jbang.run.common.Printer; import org.apache.camel.util.json.JsonObject; @@ -110,7 +111,12 @@ public class CamelJBangMain implements Command<CommandInvocation> { // the plugins whose commands were added, to add them to a new command line too private final List<Plugin> plugins = new CopyOnWriteArrayList<>(); + /** + * The main method of the CLI that JBang runs (camel-jbang-main/dist/CamelJBang.java). + */ public static void run(String... args) { + // before anything creates a logger + CliLogging.install(); run(new CamelJBangMain(), args); } diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/infra/InfraRun.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/infra/InfraRun.java index a4c9514399ad..1041c8c6bb6f 100644 --- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/infra/InfraRun.java +++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/infra/InfraRun.java @@ -41,6 +41,7 @@ import org.apache.camel.dsl.jbang.core.common.CliException; import org.apache.camel.dsl.jbang.core.common.CommandLineHelper; import org.apache.camel.dsl.jbang.core.common.EnvironmentHelper; import org.apache.camel.dsl.jbang.core.common.JsonOutput; +import org.apache.camel.dsl.jbang.run.common.CliLogging; import org.apache.camel.dsl.jbang.run.common.Printer; import org.apache.camel.dsl.jbang.run.common.RuntimeUtil; import org.apache.camel.main.download.DependencyDownloaderClassLoader; @@ -253,6 +254,7 @@ public class InfraRun extends InfraBaseCommand { URL logConfig = InfraRun.class.getClassLoader().getResource("log4j2-infra.properties"); if (logConfig != null) { Configurator.reconfigure(logConfig.toURI()); + CliLogging.loggingConfigured(); } String prefix = ""; if (testServiceImplementation != null) { diff --git a/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/CamelCommandColorsTest.java b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/CamelCommandColorsTest.java new file mode 100644 index 000000000000..20b9f1e74e00 --- /dev/null +++ b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/CamelCommandColorsTest.java @@ -0,0 +1,77 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.dsl.jbang.core.commands; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.nio.charset.StandardCharsets; + +import org.apache.camel.dsl.jbang.core.common.EnvironmentHelper; +import org.jline.jansi.Ansi; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assumptions.assumeFalse; + +/** + * Without a terminal, a command prints its colored text without the colors itself, as the console would, without + * building the JLine terminal that the console needs to find that out (CAMEL-26937). + */ +class CamelCommandColorsTest { + + @Test + void coloredTextWithoutTerminalIsPrintedWithoutColors() throws Exception { + assumeFalse(EnvironmentHelper.hasTerminal(), "runs without a terminal"); + + String out = printToConsole(new ColoredCommand(new CamelJBangMain())); + + assertThat(out).isEqualTo("red and bold" + System.lineSeparator() + "plain"); + } + + @Test + void consoleStripsTheColorsWithoutTerminal() { + assumeFalse(EnvironmentHelper.hasTerminal(), "runs without a terminal"); + + assertThat(new ColoredCommand(new CamelJBangMain()).colorsStripped()).isTrue(); + } + + private static String printToConsole(CamelCommand command) throws Exception { + PrintStream previous = System.out; + ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + System.setOut(new PrintStream(bytes, true, StandardCharsets.UTF_8)); + try { + command.doCall(); + } finally { + System.setOut(previous); + } + return bytes.toString(StandardCharsets.UTF_8); + } + + private static final class ColoredCommand extends CamelCommand { + + ColoredCommand(CamelJBangMain main) { + super(main); + } + + @Override + public Integer doCall() { + printlnColored(Ansi.ansi().fgRed().a("red").reset().a(" and ").bold().a("bold").reset()); + printColored(Ansi.ansi().a("plain")); + return 0; + } + } +} diff --git a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/CliLoggerProvider.java b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/CliLoggerProvider.java new file mode 100644 index 000000000000..1f0bb1b5c532 --- /dev/null +++ b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/CliLoggerProvider.java @@ -0,0 +1,218 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.dsl.jbang.run.common; + +import java.util.Deque; +import java.util.Map; +import java.util.ServiceLoader; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; + +import org.slf4j.ILoggerFactory; +import org.slf4j.IMarkerFactory; +import org.slf4j.Logger; +import org.slf4j.helpers.NOP_FallbackServiceProvider; +import org.slf4j.helpers.SubstituteLogger; +import org.slf4j.spi.MDCAdapter; +import org.slf4j.spi.SLF4JServiceProvider; + +/** + * The SLF4J provider of a Camel CLI started from the command line: its loggers log nothing until the CLI configures the + * logging ({@link RuntimeUtil#configureLog}), and then log with the SLF4J provider on the classpath (log4j). + * <p/> + * Most commands, such as camel ps or camel get, turn the logging off, and something that only creates a logger (a + * static logger of a class of Camel) then made log4j start, which is about a third of such a command (CAMEL-26937). + * Log4j already logged nothing until the CLI configured it (CAMEL-26429), so the commands log as before. The main + * method of the CLI installs it, see {@link CliLogging#install()}. + */ +public final class CliLoggerProvider implements SLF4JServiceProvider { + + private final CliLoggerFactory loggerFactory = new CliLoggerFactory(); + private final MDCAdapter mdcAdapter = new CliMDCAdapter(this); + private final Supplier<SLF4JServiceProvider> delegateFinder; + private volatile SLF4JServiceProvider delegate; + + /** + * The provider that SLF4J creates, as the system property {@code slf4j.provider} names it. + */ + public CliLoggerProvider() { + this(CliLoggerProvider::findProvider); + } + + CliLoggerProvider(Supplier<SLF4JServiceProvider> delegateFinder) { + this.delegateFinder = delegateFinder; + } + + /** + * The CLI configured the logging: from now on the loggers log with the provider on the classpath. + */ + void configured() { + loggerFactory.delegateTo(delegate().getLoggerFactory()); + } + + @Override + public void initialize() { + // SLF4J chose this provider, as something asked for a logger + CliLogging.bound(this::configured); + } + + @Override + public ILoggerFactory getLoggerFactory() { + return loggerFactory; + } + + @Override + public IMarkerFactory getMarkerFactory() { + return delegate().getMarkerFactory(); + } + + @Override + public MDCAdapter getMDCAdapter() { + // SLF4J asks for it when it chooses the provider, before anything logs + return mdcAdapter; + } + + @Override + public String getRequestedApiVersion() { + return "2.0.99"; + } + + // the provider on the classpath, which is found as SLF4J would without this one + private SLF4JServiceProvider delegate() { + SLF4JServiceProvider answer = delegate; + if (answer == null) { + synchronized (this) { + answer = delegate; + if (answer == null) { + answer = delegateFinder.get(); + answer.initialize(); + delegate = answer; + } + } + } + return answer; + } + + private static SLF4JServiceProvider findProvider() { + ClassLoader cl = CliLoggerProvider.class.getClassLoader(); + for (SLF4JServiceProvider provider : ServiceLoader.load(SLF4JServiceProvider.class, cl)) { + if (!(provider instanceof CliLoggerProvider)) { + return provider; + } + } + return new NOP_FallbackServiceProvider(); + } + + /** + * The loggers created before the logging is configured stand in for the loggers of the provider on the classpath, + * which they log with once it is. + */ + static final class CliLoggerFactory implements ILoggerFactory { + + private final Map<String, SubstituteLogger> loggers = new ConcurrentHashMap<>(); + private volatile ILoggerFactory delegate; + + @Override + public Logger getLogger(String name) { + ILoggerFactory factory = delegate; + if (factory != null) { + return factory.getLogger(name); + } + synchronized (this) { + factory = delegate; + if (factory != null) { + return factory.getLogger(name); + } + // a substitute logger without a delegate logs nothing + return loggers.computeIfAbsent(name, n -> new SubstituteLogger(n, null, true)); + } + } + + synchronized void delegateTo(ILoggerFactory factory) { + if (delegate == null) { + loggers.forEach((name, logger) -> logger.setDelegate(factory.getLogger(name))); + delegate = factory; + } + } + } + + /** + * The MDC of the provider on the classpath, which its layouts read, created when something first uses the MDC. + */ + static final class CliMDCAdapter implements MDCAdapter { + + private final CliLoggerProvider provider; + + CliMDCAdapter(CliLoggerProvider provider) { + this.provider = provider; + } + + private MDCAdapter adapter() { + return provider.delegate().getMDCAdapter(); + } + + @Override + public void put(String key, String val) { + adapter().put(key, val); + } + + @Override + public String get(String key) { + return adapter().get(key); + } + + @Override + public void remove(String key) { + adapter().remove(key); + } + + @Override + public void clear() { + adapter().clear(); + } + + @Override + public Map<String, String> getCopyOfContextMap() { + return adapter().getCopyOfContextMap(); + } + + @Override + public void setContextMap(Map<String, String> contextMap) { + adapter().setContextMap(contextMap); + } + + @Override + public void pushByKey(String key, String value) { + adapter().pushByKey(key, value); + } + + @Override + public String popByKey(String key) { + return adapter().popByKey(key); + } + + @Override + public Deque<String> getCopyOfDequeByKey(String key) { + return adapter().getCopyOfDequeByKey(key); + } + + @Override + public void clearDequeByKey(String key) { + adapter().clearDequeByKey(key); + } + } +} diff --git a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/CliLogging.java b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/CliLogging.java new file mode 100644 index 000000000000..4605281da79f --- /dev/null +++ b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/CliLogging.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.dsl.jbang.run.common; + +/** + * Installs the SLF4J provider of the CLI ({@link CliLoggerProvider}). A class of its own without SLF4J types, so that a + * command that never logs, such as camel version, loads no class of SLF4J. + */ +public final class CliLogging { + + // the system properties of SLF4J for the provider, and for what it reports about itself + static final String PROVIDER_PROPERTY = "slf4j.provider"; + static final String VERBOSITY_PROPERTY = "slf4j.internal.verbosity"; + + // the name of CliLoggerProvider, without loading it + static final String PROVIDER = "org.apache.camel.dsl.jbang.run.common.CliLoggerProvider"; + + // whether the CLI configured the logging, and what the provider does then once SLF4J chose it + private static volatile boolean configured; + private static Runnable onConfigured; + + private CliLogging() { + } + + /** + * Makes SLF4J use the provider of the CLI, unless another one is asked for. Call it first thing in the main method + * of the CLI, before anything creates a logger. + */ + public static void install() { + if (System.getProperty(PROVIDER_PROPERTY) == null) { + System.setProperty(PROVIDER_PROPERTY, PROVIDER); + if (System.getProperty(VERBOSITY_PROPERTY) == null) { + // SLF4J tells on stderr which provider it loads, when it is given by the system property + System.setProperty(VERBOSITY_PROPERTY, "WARN"); + } + } + } + + /** + * Whether the loggers of the CLI log nothing yet, as the CLI did not configure the logging: then nothing logged to + * log4j, and log4j is not started. + */ + static boolean isDeferred() { + return !configured && PROVIDER.equals(System.getProperty(PROVIDER_PROPERTY)); + } + + /** + * The CLI configured log4j: from now on the loggers of the CLI log with it. The CLI calls it when it configures + * log4j, see {@link RuntimeUtil#configureLog}. + */ + public static void loggingConfigured() { + Runnable task; + synchronized (CliLogging.class) { + configured = true; + task = onConfigured; + } + if (task != null) { + task.run(); + } + } + + // for the tests: as in a new JVM + static synchronized void reset() { + configured = false; + onConfigured = null; + } + + // SLF4J chose the provider of the CLI + static void bound(Runnable task) { + boolean now; + synchronized (CliLogging.class) { + onConfigured = task; + now = configured; + } + if (now) { + task.run(); + } + } +} diff --git a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/RuntimeUtil.java b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/RuntimeUtil.java index 5c43df8b4742..ee2acf78112e 100644 --- a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/RuntimeUtil.java +++ b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/common/RuntimeUtil.java @@ -169,9 +169,11 @@ public final class RuntimeUtil { System.setProperty("pid", Long.toString(pid)); // make it possible to manage log4j via JMX and camel-cli System.setProperty("log4j2.disable.jmx", "false"); - if (isOff(level, location) && !isLog4jConfigured()) { + if (isOff(level, location) && (CliLogging.isDeferred() || !isLog4jConfigured())) { // most commands log nothing with the logging off, and log4j takes about 200 ms to configure: log4j - // configures itself, with the logging off, when something first logs + // configures itself, with the logging off, when something first logs. With the SLF4J provider of + // the CLI nothing logs to log4j yet, so log4j is not even asked whether it is configured, as that + // starts it (CAMEL-26937) System.setProperty(CONFIGURATION_FILE, OFF_CONFIG); deferred = location; configured = location; @@ -199,6 +201,8 @@ public final class RuntimeUtil { } setRootLoggingLevel(level); + // log4j is configured: the loggers of the SLF4J provider of the CLI log with it from now on + CliLogging.loggingConfigured(); } private static boolean isOff(String level, String location) { diff --git a/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/common/CliLoggerProviderTest.java b/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/common/CliLoggerProviderTest.java new file mode 100644 index 000000000000..af9d8fd6228d --- /dev/null +++ b/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/common/CliLoggerProviderTest.java @@ -0,0 +1,119 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.dsl.jbang.run.common; + +import java.util.concurrent.atomic.AtomicInteger; + +import org.junit.jupiter.api.Test; +import org.slf4j.ILoggerFactory; +import org.slf4j.Logger; +import org.slf4j.spi.MDCAdapter; +import org.slf4j.spi.SLF4JServiceProvider; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * The SLF4J provider of the CLI logs nothing until the CLI configures the logging, without starting the provider on the + * classpath (log4j), and then logs with it (CAMEL-26937). The provider is not installed in this JVM: the tests use an + * instance of their own. + */ +class CliLoggerProviderTest { + + private final AtomicInteger started = new AtomicInteger(); + private final SLF4JServiceProvider log4j = mock(SLF4JServiceProvider.class); + private final ILoggerFactory log4jLoggers = mock(ILoggerFactory.class); + private final MDCAdapter log4jMdc = mock(MDCAdapter.class); + + private CliLoggerProvider provider() { + when(log4j.getLoggerFactory()).thenReturn(log4jLoggers); + when(log4j.getMDCAdapter()).thenReturn(log4jMdc); + return new CliLoggerProvider(() -> { + started.incrementAndGet(); + return log4j; + }); + } + + @Test + void loggerLogsNothingBeforeTheLoggingIsConfigured() { + CliLoggerProvider provider = provider(); + + Logger logger = provider.getLoggerFactory().getLogger("org.apache.camel.util.FileUtil"); + logger.error("not logged"); + + assertThat(logger.isErrorEnabled()).isFalse(); + assertThat(started).as("the provider on the classpath is not started").hasValue(0); + } + + @Test + void choosingTheProviderDoesNotStartLog4j() { + CliLoggerProvider provider = provider(); + + // SLF4J asks for the MDC adapter when it chooses the provider + assertThat(provider.getMDCAdapter()).isNotNull(); + + assertThat(started).hasValue(0); + } + + @Test + void loggerCreatedBeforeLogsWithTheProviderOnceConfigured() { + CliLoggerProvider provider = provider(); + Logger early = provider.getLoggerFactory().getLogger("early"); + Logger log4jLogger = mock(Logger.class); + when(log4jLogger.isInfoEnabled()).thenReturn(true); + when(log4jLoggers.getLogger("early")).thenReturn(log4jLogger); + + provider.configured(); + early.info("hello {}", "world"); + + assertThat(early.isInfoEnabled()).isTrue(); + verify(log4jLogger).info("hello {}", "world"); + assertThat(started).hasValue(1); + } + + @Test + void loggerCreatedAfterIsTheLoggerOfTheProvider() { + CliLoggerProvider provider = provider(); + Logger log4jLogger = mock(Logger.class); + when(log4jLoggers.getLogger("late")).thenReturn(log4jLogger); + + provider.configured(); + + assertThat(provider.getLoggerFactory().getLogger("late")).isSameAs(log4jLogger); + } + + @Test + void configuredTwiceStartsTheProviderOnce() { + CliLoggerProvider provider = provider(); + + provider.configured(); + provider.configured(); + + assertThat(started).hasValue(1); + } + + @Test + void mdcIsTheMdcOfTheProvider() { + CliLoggerProvider provider = provider(); + + provider.getMDCAdapter().put("camel.exchangeId", "1"); + + verify(log4jMdc).put("camel.exchangeId", "1"); + } +} diff --git a/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/common/CliLoggingTest.java b/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/common/CliLoggingTest.java new file mode 100644 index 000000000000..acdf54ae9bf4 --- /dev/null +++ b/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/common/CliLoggingTest.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.dsl.jbang.run.common; + +import java.util.concurrent.atomic.AtomicInteger; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junitpioneer.jupiter.ClearSystemProperty; +import org.junitpioneer.jupiter.SetSystemProperty; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * The CLI tells its SLF4J provider when it configured the logging, also when SLF4J chooses the provider only after that + * (CAMEL-26937). + */ +class CliLoggingTest { + + private final AtomicInteger configured = new AtomicInteger(); + + @BeforeEach + @AfterEach + void newJvm() { + CliLogging.reset(); + } + + @Test + void providerChosenBeforeTheLoggingIsConfigured() { + CliLogging.bound(configured::incrementAndGet); + assertThat(configured).hasValue(0); + + CliLogging.loggingConfigured(); + + assertThat(configured).hasValue(1); + } + + @Test + void providerChosenAfterTheLoggingIsConfigured() { + CliLogging.loggingConfigured(); + + CliLogging.bound(configured::incrementAndGet); + + assertThat(configured).hasValue(1); + } + + @Test + @SetSystemProperty(key = CliLogging.PROVIDER_PROPERTY, value = CliLogging.PROVIDER) + void deferredUntilTheLoggingIsConfigured() { + assertThat(CliLogging.isDeferred()).isTrue(); + + CliLogging.loggingConfigured(); + + assertThat(CliLogging.isDeferred()).isFalse(); + } + + @Test + @ClearSystemProperty(key = CliLogging.PROVIDER_PROPERTY) + void notDeferredWithAnotherProvider() { + // a JVM that did not start from the main method of the CLI, such as the tests of the commands + assertThat(CliLogging.isDeferred()).isFalse(); + } + + @Test + void providerName() { + assertThat(CliLogging.PROVIDER).isEqualTo(CliLoggerProvider.class.getName()); + } +} diff --git a/dsl/camel-jbang/camel-launcher/src/main/java/org/apache/camel/dsl/jbang/launcher/CamelLauncher.java b/dsl/camel-jbang/camel-launcher/src/main/java/org/apache/camel/dsl/jbang/launcher/CamelLauncher.java index af7fef3a6611..1909903d9697 100644 --- a/dsl/camel-jbang/camel-launcher/src/main/java/org/apache/camel/dsl/jbang/launcher/CamelLauncher.java +++ b/dsl/camel-jbang/camel-launcher/src/main/java/org/apache/camel/dsl/jbang/launcher/CamelLauncher.java @@ -17,6 +17,7 @@ package org.apache.camel.dsl.jbang.launcher; import org.apache.camel.dsl.jbang.core.common.LauncherHelper; +import org.apache.camel.dsl.jbang.run.common.CliLogging; /** * Main class for the Camel CLI Fat-Jar Launcher. @@ -32,6 +33,9 @@ public class CamelLauncher { * @param args command line arguments to pass to Camel CLI */ public static void main(String... args) { + // before anything creates a logger: the loggers log nothing until the CLI configures the logging, so a command + // that turns the logging off does not start log4j + CliLogging.install(); System.setProperty(LauncherHelper.CAMEL_LAUNCHER_PROPERTY, "true"); // The JAR of this class, which the CLI runs again in another process: the fat JAR, or the launcher JAR in lib/ diff --git a/dsl/camel-jbang/camel-launcher/src/test/java/org/apache/camel/dsl/jbang/launcher/LauncherStartupLoggingTest.java b/dsl/camel-jbang/camel-launcher/src/test/java/org/apache/camel/dsl/jbang/launcher/LauncherStartupLoggingTest.java index c4d837270610..f9355f035415 100644 --- a/dsl/camel-jbang/camel-launcher/src/test/java/org/apache/camel/dsl/jbang/launcher/LauncherStartupLoggingTest.java +++ b/dsl/camel-jbang/camel-launcher/src/test/java/org/apache/camel/dsl/jbang/launcher/LauncherStartupLoggingTest.java @@ -60,6 +60,17 @@ class LauncherStartupLoggingTest { assertNoLogging(classes); } + @Test + void aCommandWithTheLoggingOffDoesNotStartLog4j() throws Exception { + // camel doc creates loggers (of the catalog), which made log4j start, only to log nothing (CAMEL-26937) + List<String> classes = run(CamelLauncher.class.getName(), "doc", "timer"); + + assertThat(classes).as("the SLF4J provider of the CLI") + .contains("org.apache.camel.dsl.jbang.run.common.CliLoggerProvider"); + assertThat(classes.stream().filter(c -> c.startsWith("org.apache.logging.log4j."))).as("log4j is not started") + .isEmpty(); + } + private static void assertNoLogging(List<String> classes) { assertThat(classes.stream().filter(c -> c.startsWith("org.slf4j."))).as("no logger").isEmpty(); assertThat(classes.stream().filter(c -> c.startsWith("org.apache.logging.log4j.core.appender.")))
