- 3.0.2-SNAPSHOT
+ 3.0.2
3.2.1
0.5.6-jdk17-SNAPSHOT
UTF-8
diff --git a/sofa-serverless-runtime/sofa-serverless-adapter-ext/pom.xml b/sofa-serverless-runtime/sofa-serverless-adapter-ext/pom.xml
index 9bdc21d57..c725f0730 100644
--- a/sofa-serverless-runtime/sofa-serverless-adapter-ext/pom.xml
+++ b/sofa-serverless-runtime/sofa-serverless-adapter-ext/pom.xml
@@ -13,6 +13,7 @@
pom
+ sofa-serverless-adapter-log4j2
sofa-serverless-adapter-logback
sofa-serverless-adapter-apollo
diff --git a/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/pom.xml b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/pom.xml
new file mode 100644
index 000000000..ddab63580
--- /dev/null
+++ b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/pom.xml
@@ -0,0 +1,75 @@
+
+
+ 4.0.0
+
+ com.alipay.sofa.serverless
+ sofa-serverless-adapter-ext
+ ${revision}
+ ../pom.xml
+
+ sofa-serverless-adapter-log4j2
+ ${revision}
+
+
+
+ org.springframework.boot
+ spring-boot-starter
+ ${spring.boot.version}
+ provided
+
+
+ org.springframework.boot
+ spring-boot-starter-logging
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-log4j2
+ ${spring.boot.version}
+ provided
+
+
+ com.alipay.sofa
+ sofa-ark-spi
+ provided
+
+
+
+
+
+
+ com.alipay.sofa
+ sofa-ark-plugin-maven-plugin
+ ${sofa.ark.version}
+
+
+ default-cli
+
+ ark-plugin
+
+
+
+
+ com.alipay.sofa.serverless.adapter.Log4j2AdapterActivator
+
+
+
+
+
+ org.springframework.boot.logging.log4j2.Log4J2LoggingSystem
+
+
+
+
+ *:*:*
+ com.alipay.sofa.serverless:sofa-serverless-adapter-log4j2
+
+
+
+
+
+
+
+
diff --git a/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/com/alipay/sofa/serverless/adapter/Log4j2AdapterActivator.java b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/com/alipay/sofa/serverless/adapter/Log4j2AdapterActivator.java
new file mode 100644
index 000000000..6f7c44c75
--- /dev/null
+++ b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/com/alipay/sofa/serverless/adapter/Log4j2AdapterActivator.java
@@ -0,0 +1,35 @@
+/*
+ * 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 com.alipay.sofa.serverless.adapter;
+
+import com.alipay.sofa.ark.spi.model.PluginContext;
+import com.alipay.sofa.ark.spi.service.PluginActivator;
+
+/**
+ * @author lvjing2
+ * @since 0.5.5
+ */
+public class Log4j2AdapterActivator implements PluginActivator {
+ @Override
+ public void start(PluginContext context) {
+ }
+
+ @Override
+ public void stop(PluginContext context) {
+ // no op
+ }
+}
diff --git a/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/org/springframework/boot/context/logging/LoggingApplicationListener.java b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/org/springframework/boot/context/logging/LoggingApplicationListener.java
new file mode 100644
index 000000000..be6c496a3
--- /dev/null
+++ b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/org/springframework/boot/context/logging/LoggingApplicationListener.java
@@ -0,0 +1,522 @@
+/*
+ * 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.springframework.boot.context.logging;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.logging.log4j.ThreadContext;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;
+import org.springframework.boot.context.event.ApplicationFailedEvent;
+import org.springframework.boot.context.event.ApplicationPreparedEvent;
+import org.springframework.boot.context.event.ApplicationStartingEvent;
+import org.springframework.boot.context.properties.bind.Bindable;
+import org.springframework.boot.context.properties.bind.Binder;
+import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
+import org.springframework.boot.logging.LogFile;
+import org.springframework.boot.logging.LogLevel;
+import org.springframework.boot.logging.LoggerGroup;
+import org.springframework.boot.logging.LoggerGroups;
+import org.springframework.boot.logging.LoggingInitializationContext;
+import org.springframework.boot.logging.LoggingSystem;
+import org.springframework.boot.logging.LoggingSystemProperties;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationEvent;
+import org.springframework.context.ApplicationListener;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.SmartLifecycle;
+import org.springframework.context.event.ContextClosedEvent;
+import org.springframework.context.event.GenericApplicationListener;
+import org.springframework.core.Ordered;
+import org.springframework.core.ResolvableType;
+import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.env.EnumerablePropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.core.log.LogMessage;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.util.StringUtils;
+
+import java.io.FileNotFoundException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+
+/**
+ * An {@link ApplicationListener} that configures the {@link LoggingSystem}. If the
+ * environment contains a {@code logging.config} property it will be used to bootstrap the
+ * logging system, otherwise a default configuration is used. Regardless, logging levels
+ * will be customized if the environment contains {@code logging.level.*} entries and
+ * logging groups can be defined with {@code logging.group}.
+ *
+ * Debug and trace logging for Spring, Tomcat, Jetty and Hibernate will be enabled when
+ * the environment contains {@code debug} or {@code trace} properties that aren't set to
+ * {@code "false"} (i.e. if you start your application using
+ * {@literal java -jar myapp.jar [--debug | --trace]}). If you prefer to ignore these
+ * properties you can set {@link #setParseArgs(boolean) parseArgs} to {@code false}.
+ *
+ * By default, log output is only written to the console. If a log file is required, the
+ * {@code logging.file.path} and {@code logging.file.name} properties can be used.
+ *
+ * Some system properties may be set as side effects, and these can be useful if the
+ * logging configuration supports placeholders (i.e. log4j or logback):
+ *
+ * - {@code LOG_FILE} is set to the value of path of the log file that should be written
+ * (if any).
+ * - {@code PID} is set to the value of the current process ID if it can be determined.
+ *
+ *
+ *
+ * @author Dave Syer
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ * @author Madhura Bhave
+ * @author HaiTao Zhang
+ * @since 2.0.0
+ * @see LoggingSystem#get(ClassLoader)
+ */
+public class LoggingApplicationListener implements GenericApplicationListener {
+
+ private static final ConfigurationPropertyName LOGGING_LEVEL = ConfigurationPropertyName
+ .of("logging.level");
+
+ private static final ConfigurationPropertyName LOGGING_GROUP = ConfigurationPropertyName
+ .of("logging.group");
+
+ private static final Bindable> STRING_LOGLEVEL_MAP = Bindable
+ .mapOf(
+ String.class,
+ LogLevel.class);
+
+ private static final Bindable>> STRING_STRINGS_MAP = Bindable
+ .of(ResolvableType
+ .forClassWithGenerics(
+ MultiValueMap.class,
+ String.class,
+ String.class)
+ .asMap());
+
+ /**
+ * The default order for the LoggingApplicationListener.
+ */
+ public static final int DEFAULT_ORDER = Ordered.HIGHEST_PRECEDENCE + 20;
+
+ /**
+ * The name of the Spring property that contains a reference to the logging
+ * configuration to load.
+ */
+ public static final String CONFIG_PROPERTY = "logging.config";
+
+ /**
+ * The name of the Spring property that controls the registration of a shutdown hook
+ * to shut down the logging system when the JVM exits.
+ * @see LoggingSystem#getShutdownHandler
+ */
+ public static final String REGISTER_SHUTDOWN_HOOK_PROPERTY = "logging.register-shutdown-hook";
+
+ /**
+ * The name of the {@link LoggingSystem} bean.
+ */
+ public static final String LOGGING_SYSTEM_BEAN_NAME = "springBootLoggingSystem";
+
+ /**
+ * The name of the {@link LogFile} bean.
+ * @since 2.2.0
+ */
+ public static final String LOG_FILE_BEAN_NAME = "springBootLogFile";
+
+ /**
+ * The name of the {@link LoggerGroups} bean.
+ * @since 2.2.0
+ */
+ public static final String LOGGER_GROUPS_BEAN_NAME = "springBootLoggerGroups";
+
+ /**
+ * The name of the {@link Lifecycle} bean used to handle cleanup.
+ */
+ private static final String LOGGING_LIFECYCLE_BEAN_NAME = "springBootLoggingLifecycle";
+
+ private static final Map> DEFAULT_GROUP_LOGGERS;
+ static {
+ MultiValueMap loggers = new LinkedMultiValueMap<>();
+ loggers.add("web", "org.springframework.core.codec");
+ loggers.add("web", "org.springframework.http");
+ loggers.add("web", "org.springframework.web");
+ loggers.add("web", "org.springframework.boot.actuate.endpoint.web");
+ loggers.add("web", "org.springframework.boot.web.servlet.ServletContextInitializerBeans");
+ loggers.add("sql", "org.springframework.jdbc.core");
+ loggers.add("sql", "org.hibernate.SQL");
+ loggers.add("sql", "org.jooq.tools.LoggerListener");
+ DEFAULT_GROUP_LOGGERS = Collections.unmodifiableMap(loggers);
+ }
+
+ private static final Map> SPRING_BOOT_LOGGING_LOGGERS;
+ static {
+ MultiValueMap loggers = new LinkedMultiValueMap<>();
+ loggers.add(LogLevel.DEBUG, "sql");
+ loggers.add(LogLevel.DEBUG, "web");
+ loggers.add(LogLevel.DEBUG, "org.springframework.boot");
+ loggers.add(LogLevel.TRACE, "org.springframework");
+ loggers.add(LogLevel.TRACE, "org.apache.tomcat");
+ loggers.add(LogLevel.TRACE, "org.apache.catalina");
+ loggers.add(LogLevel.TRACE, "org.eclipse.jetty");
+ loggers.add(LogLevel.TRACE, "org.hibernate.tool.hbm2ddl");
+ SPRING_BOOT_LOGGING_LOGGERS = Collections.unmodifiableMap(loggers);
+ }
+
+ private static final Class[] EVENT_TYPES = {
+ ApplicationStartingEvent.class, ApplicationEnvironmentPreparedEvent.class,
+ ApplicationPreparedEvent.class, ContextClosedEvent.class, ApplicationFailedEvent.class };
+
+ private static final Class[] SOURCE_TYPES = {
+ SpringApplication.class, ApplicationContext.class };
+
+ private static final AtomicBoolean shutdownHookRegistered = new AtomicBoolean();
+
+ private final Log logger = LogFactory
+ .getLog(getClass());
+
+ private LoggingSystem loggingSystem;
+
+ private LogFile logFile;
+
+ private LoggerGroups loggerGroups;
+
+ private int order = DEFAULT_ORDER;
+
+ private boolean parseArgs = true;
+
+ private LogLevel springBootLogging = null;
+
+ @Override
+ public boolean supportsEventType(ResolvableType resolvableType) {
+ return isAssignableFrom(resolvableType.getRawClass(), EVENT_TYPES);
+ }
+
+ @Override
+ public boolean supportsSourceType(Class sourceType) {
+ return isAssignableFrom(sourceType, SOURCE_TYPES);
+ }
+
+ private boolean isAssignableFrom(Class type, Class... supportedTypes) {
+ if (type != null) {
+ for (Class supportedType : supportedTypes) {
+ if (supportedType.isAssignableFrom(type)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public void onApplicationEvent(ApplicationEvent event) {
+ if (event instanceof ApplicationStartingEvent) {
+ onApplicationStartingEvent((ApplicationStartingEvent) event);
+ } else if (event instanceof ApplicationEnvironmentPreparedEvent) {
+ onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
+ } else if (event instanceof ApplicationPreparedEvent) {
+ onApplicationPreparedEvent((ApplicationPreparedEvent) event);
+ } else if (event instanceof ContextClosedEvent) {
+ onContextClosedEvent((ContextClosedEvent) event);
+ } else if (event instanceof ApplicationFailedEvent) {
+ onApplicationFailedEvent();
+ }
+ }
+
+ private void onApplicationStartingEvent(ApplicationStartingEvent event) {
+ this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
+ this.loggingSystem.beforeInitialize();
+ }
+
+ private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
+ SpringApplication springApplication = event.getSpringApplication();
+ if (this.loggingSystem == null) {
+ this.loggingSystem = LoggingSystem.get(springApplication.getClassLoader());
+ }
+ initialize(event.getEnvironment(), springApplication.getClassLoader());
+ }
+
+ private void onApplicationPreparedEvent(ApplicationPreparedEvent event) {
+ ConfigurableApplicationContext applicationContext = event.getApplicationContext();
+ ConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();
+ if (!beanFactory.containsBean(LOGGING_SYSTEM_BEAN_NAME)) {
+ beanFactory.registerSingleton(LOGGING_SYSTEM_BEAN_NAME, this.loggingSystem);
+ }
+ if (this.logFile != null && !beanFactory.containsBean(LOG_FILE_BEAN_NAME)) {
+ beanFactory.registerSingleton(LOG_FILE_BEAN_NAME, this.logFile);
+ }
+ if (this.loggerGroups != null && !beanFactory.containsBean(LOGGER_GROUPS_BEAN_NAME)) {
+ beanFactory.registerSingleton(LOGGER_GROUPS_BEAN_NAME, this.loggerGroups);
+ }
+ if (!beanFactory.containsBean(LOGGING_LIFECYCLE_BEAN_NAME)
+ && applicationContext.getParent() == null) {
+ beanFactory.registerSingleton(LOGGING_LIFECYCLE_BEAN_NAME, new Lifecycle());
+ }
+ }
+
+ private void onContextClosedEvent(ContextClosedEvent event) {
+ ApplicationContext applicationContext = event.getApplicationContext();
+ if (applicationContext.getParent() != null
+ || applicationContext.containsBean(LOGGING_LIFECYCLE_BEAN_NAME)) {
+ return;
+ }
+ cleanupLoggingSystem();
+ }
+
+ void cleanupLoggingSystem() {
+ if (this.loggingSystem != null) {
+ this.loggingSystem.cleanUp();
+ }
+ }
+
+ private void onApplicationFailedEvent() {
+ cleanupLoggingSystem();
+ }
+
+ /**
+ * Initialize the logging system according to preferences expressed through the
+ * {@link Environment} and the classpath.
+ * @param environment the environment
+ * @param classLoader the classloader
+ */
+ protected void initialize(ConfigurableEnvironment environment, ClassLoader classLoader) {
+ getLoggingSystemProperties(environment).apply();
+ this.logFile = LogFile.get(environment);
+ if (this.logFile != null) {
+ this.logFile.applyToSystemProperties();
+ }
+ this.loggerGroups = new LoggerGroups(DEFAULT_GROUP_LOGGERS);
+ initializeEarlyLoggingLevel(environment);
+ initalizeThreadContextConfig(environment);
+ initializeSystem(environment, this.loggingSystem, this.logFile);
+ initializeFinalLoggingLevels(environment, this.loggingSystem);
+ registerShutdownHookIfNecessary(environment, this.loggingSystem);
+ }
+
+ private LoggingSystemProperties getLoggingSystemProperties(ConfigurableEnvironment environment) {
+ return (this.loggingSystem != null) ? this.loggingSystem.getSystemProperties(environment)
+ : new LoggingSystemProperties(environment);
+ }
+
+ private void initializeEarlyLoggingLevel(ConfigurableEnvironment environment) {
+ if (this.parseArgs && this.springBootLogging == null) {
+ if (isSet(environment, "debug")) {
+ this.springBootLogging = LogLevel.DEBUG;
+ }
+ if (isSet(environment, "trace")) {
+ this.springBootLogging = LogLevel.TRACE;
+ }
+ }
+ }
+
+ private boolean isSet(ConfigurableEnvironment environment, String property) {
+ String value = environment.getProperty(property);
+ return (value != null && !value.equals("false"));
+ }
+
+ private void initializeSystem(ConfigurableEnvironment environment, LoggingSystem system,
+ LogFile logFile) {
+ String logConfig = StringUtils.trimWhitespace(environment.getProperty(CONFIG_PROPERTY));
+ try {
+ LoggingInitializationContext initializationContext = new LoggingInitializationContext(
+ environment);
+ if (ignoreLogConfig(logConfig)) {
+ system.initialize(initializationContext, null, logFile);
+ } else {
+ system.initialize(initializationContext, logConfig, logFile);
+ }
+ } catch (Exception ex) {
+ Throwable exceptionToReport = ex;
+ while (exceptionToReport != null
+ && !(exceptionToReport instanceof FileNotFoundException)) {
+ exceptionToReport = exceptionToReport.getCause();
+ }
+ exceptionToReport = (exceptionToReport != null) ? exceptionToReport : ex;
+ // NOTE: We can't use the logger here to report the problem
+ System.err.println("Logging system failed to initialize using configuration from '"
+ + logConfig + "'");
+ exceptionToReport.printStackTrace(System.err);
+ throw new IllegalStateException(ex);
+ }
+ }
+
+ private boolean ignoreLogConfig(String logConfig) {
+ return !StringUtils.hasLength(logConfig) || logConfig.startsWith("-D");
+ }
+
+ private void initializeFinalLoggingLevels(ConfigurableEnvironment environment,
+ LoggingSystem system) {
+ bindLoggerGroups(environment);
+ if (this.springBootLogging != null) {
+ initializeSpringBootLogging(system, this.springBootLogging);
+ }
+ setLogLevels(system, environment);
+ }
+
+ private void initalizeThreadContextConfig(ConfigurableEnvironment environment) {
+ Map configMap = new ConcurrentHashMap<>();
+ Set configKeys = new HashSet<>();
+ environment.getPropertySources().stream().filter(propertySource -> propertySource instanceof EnumerablePropertySource)
+ .forEach(propertySource -> configKeys.addAll(Arrays.asList(((EnumerablePropertySource)propertySource).getPropertyNames())));
+
+ configKeys.forEach(key -> {
+ try {
+ configMap.put(key, environment.getProperty(key));
+ } catch (Throwable t) {
+ // ignore, 异常在 AlipayPrintEnvironmentListener 中打印
+ }
+ });
+
+ configMap.forEach(ThreadContext::put);
+ }
+
+ private void bindLoggerGroups(ConfigurableEnvironment environment) {
+ if (this.loggerGroups != null) {
+ Binder binder = Binder.get(environment);
+ binder.bind(LOGGING_GROUP, STRING_STRINGS_MAP).ifBound(this.loggerGroups::putAll);
+ }
+ }
+
+ /**
+ * Initialize loggers based on the {@link #setSpringBootLogging(LogLevel)
+ * springBootLogging} setting. By default this implementation will pick an appropriate
+ * set of loggers to configure based on the level.
+ * @param system the logging system
+ * @param springBootLogging the spring boot logging level requested
+ * @since 2.2.0
+ */
+ protected void initializeSpringBootLogging(LoggingSystem system, LogLevel springBootLogging) {
+ BiConsumer configurer = getLogLevelConfigurer(system);
+ SPRING_BOOT_LOGGING_LOGGERS.getOrDefault(springBootLogging, Collections.emptyList())
+ .forEach((name) -> configureLogLevel(name, springBootLogging, configurer));
+ }
+
+ /**
+ * Set logging levels based on relevant {@link Environment} properties.
+ * @param system the logging system
+ * @param environment the environment
+ * @since 2.2.0
+ */
+ protected void setLogLevels(LoggingSystem system, ConfigurableEnvironment environment) {
+ BiConsumer customizer = getLogLevelConfigurer(system);
+ Binder binder = Binder.get(environment);
+ Map levels = binder.bind(LOGGING_LEVEL, STRING_LOGLEVEL_MAP).orElseGet(Collections::emptyMap);
+ levels.forEach((name, level) -> configureLogLevel(name, level, customizer));
+ }
+
+ private void configureLogLevel(String name, LogLevel level,
+ BiConsumer configurer) {
+ if (this.loggerGroups != null) {
+ LoggerGroup group = this.loggerGroups.get(name);
+ if (group != null && group.hasMembers()) {
+ group.configureLogLevel(level, configurer);
+ return;
+ }
+ }
+ configurer.accept(name, level);
+ }
+
+ private BiConsumer getLogLevelConfigurer(LoggingSystem system) {
+ return (name, level) -> {
+ try {
+ name = name.equalsIgnoreCase(LoggingSystem.ROOT_LOGGER_NAME) ? null : name;
+ system.setLogLevel(name, level);
+ }
+ catch (RuntimeException ex) {
+ this.logger.error(LogMessage.format("Cannot set level '%s' for '%s'", level, name));
+ }
+ };
+ }
+
+ private void registerShutdownHookIfNecessary(Environment environment,
+ LoggingSystem loggingSystem) {
+ if (environment.getProperty(REGISTER_SHUTDOWN_HOOK_PROPERTY, Boolean.class, true)) {
+ Runnable shutdownHandler = loggingSystem.getShutdownHandler();
+ if (shutdownHandler != null && shutdownHookRegistered.compareAndSet(false, true)) {
+ registerShutdownHook(shutdownHandler);
+ }
+ }
+ }
+
+ void registerShutdownHook(Runnable shutdownHandler) {
+ SpringApplication.getShutdownHandlers().add(shutdownHandler);
+ }
+
+ public void setOrder(int order) {
+ this.order = order;
+ }
+
+ @Override
+ public int getOrder() {
+ return this.order;
+ }
+
+ /**
+ * Sets a custom logging level to be used for Spring Boot and related libraries.
+ * @param springBootLogging the logging level
+ */
+ public void setSpringBootLogging(LogLevel springBootLogging) {
+ this.springBootLogging = springBootLogging;
+ }
+
+ /**
+ * Sets if initialization arguments should be parsed for {@literal debug} and
+ * {@literal trace} properties (usually defined from {@literal --debug} or
+ * {@literal --trace} command line args). Defaults to {@code true}.
+ * @param parseArgs if arguments should be parsed
+ */
+ public void setParseArgs(boolean parseArgs) {
+ this.parseArgs = parseArgs;
+ }
+
+ private class Lifecycle implements SmartLifecycle {
+
+ private volatile boolean running;
+
+ @Override
+ public void start() {
+ this.running = true;
+ }
+
+ @Override
+ public void stop() {
+ this.running = false;
+ cleanupLoggingSystem();
+ }
+
+ @Override
+ public boolean isRunning() {
+ return this.running;
+ }
+
+ @Override
+ public int getPhase() {
+ // Shutdown late and always after WebServerStartStopLifecycle
+ return Integer.MIN_VALUE + 1;
+ }
+
+ }
+
+}
diff --git a/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java
new file mode 100644
index 000000000..873e064a5
--- /dev/null
+++ b/sofa-serverless-runtime/sofa-serverless-adapter-ext/sofa-serverless-adapter-log4j2/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java
@@ -0,0 +1,465 @@
+/*
+ * 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.springframework.boot.logging.log4j2;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.config.AbstractConfiguration;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.ConfigurationFactory;
+import org.apache.logging.log4j.core.config.ConfigurationSource;
+import org.apache.logging.log4j.core.config.LoggerConfig;
+import org.apache.logging.log4j.core.config.composite.CompositeConfiguration;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.util.NameUtil;
+import org.apache.logging.log4j.message.Message;
+
+import org.springframework.boot.context.properties.bind.BindResult;
+import org.springframework.boot.context.properties.bind.Bindable;
+import org.springframework.boot.context.properties.bind.Binder;
+import org.springframework.boot.logging.*;
+import org.springframework.boot.logging.LoggerConfiguration.LevelConfiguration;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.ResourceUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * {@link LoggingSystem} for Log4j 2.
+ *
+ * @author Daniel Fullarton
+ * @author Andy Wilkinson
+ * @author Alexander Heusingfeld
+ * @author Ben Hale
+ * @since 1.2.0
+ */
+public class Log4J2LoggingSystem extends AbstractLoggingSystem {
+
+ private static final String FILE_PROTOCOL = "file";
+
+ private static final LogLevels LEVELS = new LogLevels<>();
+
+ static {
+ LEVELS.map(LogLevel.TRACE, Level.TRACE);
+ LEVELS.map(LogLevel.DEBUG, Level.DEBUG);
+ LEVELS.map(LogLevel.INFO, Level.INFO);
+ LEVELS.map(LogLevel.WARN, Level.WARN);
+ LEVELS.map(LogLevel.ERROR, Level.ERROR);
+ LEVELS.map(LogLevel.FATAL, Level.FATAL);
+ LEVELS.map(LogLevel.OFF, Level.OFF);
+ }
+
+ private static final Filter FILTER = new AbstractFilter() {
+
+ @Override
+ public Result filter(LogEvent event) {
+ return Result.DENY;
+ }
+
+ @Override
+ public Result filter(Logger logger,
+ Level level,
+ Marker marker,
+ Message msg,
+ Throwable t) {
+ return Result.DENY;
+ }
+
+ @Override
+ public Result filter(Logger logger,
+ Level level,
+ Marker marker,
+ Object msg,
+ Throwable t) {
+ return Result.DENY;
+ }
+
+ @Override
+ public Result filter(Logger logger,
+ Level level,
+ Marker marker,
+ String msg,
+ Object... params) {
+ return Result.DENY;
+ }
+
+ };
+
+ public Log4J2LoggingSystem(ClassLoader classLoader) {
+ super(classLoader);
+ }
+
+ @Override
+ protected String[] getStandardConfigLocations() {
+ return getCurrentlySupportedConfigLocations();
+ }
+
+ private String[] getCurrentlySupportedConfigLocations() {
+ List supportedConfigLocations = new ArrayList<>();
+ addTestFiles(supportedConfigLocations);
+ supportedConfigLocations.add("log4j2.properties");
+ if (isClassAvailable("com.fasterxml.jackson.dataformat.yaml.YAMLParser")) {
+ Collections.addAll(supportedConfigLocations, "log4j2.yaml", "log4j2.yml");
+ }
+ if (isClassAvailable("com.fasterxml.jackson.databind.ObjectMapper")) {
+ Collections.addAll(supportedConfigLocations, "log4j2.json", "log4j2.jsn");
+ }
+ supportedConfigLocations.add("log4j2.xml");
+ return StringUtils.toStringArray(supportedConfigLocations);
+ }
+
+ private void addTestFiles(List supportedConfigLocations) {
+ supportedConfigLocations.add("log4j2-test.properties");
+ if (isClassAvailable("com.fasterxml.jackson.dataformat.yaml.YAMLParser")) {
+ Collections.addAll(supportedConfigLocations, "log4j2-test.yaml", "log4j2-test.yml");
+ }
+ if (isClassAvailable("com.fasterxml.jackson.databind.ObjectMapper")) {
+ Collections.addAll(supportedConfigLocations, "log4j2-test.json", "log4j2-test.jsn");
+ }
+ supportedConfigLocations.add("log4j2-test.xml");
+ }
+
+ protected boolean isClassAvailable(String className) {
+ return ClassUtils.isPresent(className, getClassLoader());
+ }
+
+ @Override
+ public void beforeInitialize() {
+ LoggerContext loggerContext = getLoggerContext();
+ if (isAlreadyInitialized(loggerContext)) {
+ return;
+ }
+ super.beforeInitialize();
+ loggerContext.getConfiguration().addFilter(FILTER);
+ }
+
+ @Override
+ public void initialize(LoggingInitializationContext initializationContext,
+ String configLocation, LogFile logFile) {
+ LoggerContext loggerContext = getLoggerContext();
+ if (isAlreadyInitialized(loggerContext)) {
+ return;
+ }
+ loggerContext.getConfiguration().removeFilter(FILTER);
+ super.initialize(initializationContext, configLocation, logFile);
+ markAsInitialized(loggerContext);
+ }
+
+ @Override
+ protected void loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile) {
+ if (logFile != null) {
+ loadConfiguration(getPackagedConfigFile("log4j2-file.xml"), logFile,
+ getOverrides(initializationContext));
+ } else {
+ loadConfiguration(getPackagedConfigFile("log4j2.xml"), logFile,
+ getOverrides(initializationContext));
+ }
+ }
+
+ private List getOverrides(LoggingInitializationContext initializationContext) {
+ BindResult> overrides = Binder.get(initializationContext.getEnvironment())
+ .bind("logging.log4j2.config.override", Bindable.listOf(String.class));
+ return overrides.orElse(Collections.emptyList());
+ }
+
+ @Override
+ protected void loadConfiguration(LoggingInitializationContext initializationContext,
+ String location, LogFile logFile) {
+ if (initializationContext != null) {
+ applySystemProperties(initializationContext.getEnvironment(), logFile);
+ }
+ loadConfiguration(location, logFile, getOverrides(initializationContext));
+ }
+
+ /**
+ * Load the configuration from the given {@code location}.
+ * @param location the location
+ * @param logFile log file configuration
+ * @deprecated since 2.6.0 for removal in 3.0.0 in favor of
+ * {@link #loadConfiguration(String, LogFile, List)}
+ */
+ @Deprecated
+ protected void loadConfiguration(String location, LogFile logFile) {
+ this.loadConfiguration(location, logFile, Collections.emptyList());
+ }
+
+ /**
+ * Load the configuration from the given {@code location}, creating a composite using
+ * the configuration from the given {@code overrides}.
+ * @param location the location
+ * @param logFile log file configuration
+ * @param overrides the overriding locations
+ * @since 2.6.0
+ */
+ protected void loadConfiguration(String location, LogFile logFile, List overrides) {
+ Assert.notNull(location, "Location must not be null");
+ try {
+ List configurations = new ArrayList<>();
+ LoggerContext context = getLoggerContext();
+ configurations.add(load(location, context));
+ for (String override : overrides) {
+ configurations.add(load(override, context));
+ }
+ Configuration configuration = (configurations.size() > 1) ? createComposite(configurations)
+ : configurations.iterator().next();
+ context.start(configuration);
+ } catch (Exception ex) {
+ throw new IllegalStateException("Could not initialize Log4J2 logging from " + location,
+ ex);
+ }
+ }
+
+ private Configuration load(String location, LoggerContext context) throws IOException {
+ URL url = ResourceUtils.getURL(location);
+ ConfigurationSource source = getConfigurationSource(url);
+ return ConfigurationFactory.getInstance().getConfiguration(context, source);
+ }
+
+ private ConfigurationSource getConfigurationSource(URL url) throws IOException {
+ InputStream stream = url.openStream();
+ if (FILE_PROTOCOL.equals(url.getProtocol())) {
+ return new ConfigurationSource(stream, ResourceUtils.getFile(url));
+ }
+ return new ConfigurationSource(stream, url);
+ }
+
+ private CompositeConfiguration createComposite(List configurations) {
+ return new CompositeConfiguration(
+ configurations.stream().map(AbstractConfiguration.class::cast).collect(Collectors.toList()));
+ }
+
+ @Override
+ protected void reinitialize(LoggingInitializationContext initializationContext) {
+ List overrides = getOverrides(initializationContext);
+ if (!CollectionUtils.isEmpty(overrides)) {
+ reinitializeWithOverrides(overrides);
+ } else {
+ LoggerContext context = getLoggerContext();
+ context.reconfigure();
+ }
+ }
+
+ private void reinitializeWithOverrides(List overrides) {
+ LoggerContext context = getLoggerContext();
+ Configuration base = context.getConfiguration();
+ List configurations = new ArrayList<>();
+ configurations.add((AbstractConfiguration) base);
+ for (String override : overrides) {
+ try {
+ configurations.add((AbstractConfiguration) load(override, context));
+ } catch (IOException ex) {
+ throw new RuntimeException("Failed to load overriding configuration from '"
+ + override + "'", ex);
+ }
+ }
+ CompositeConfiguration composite = new CompositeConfiguration(configurations);
+ context.reconfigure(composite);
+ }
+
+ @Override
+ public Set getSupportedLogLevels() {
+ return LEVELS.getSupported();
+ }
+
+ @Override
+ public void setLogLevel(String loggerName, LogLevel logLevel) {
+ setLogLevel(loggerName, LEVELS.convertSystemToNative(logLevel));
+ }
+
+ private void setLogLevel(String loggerName, Level level) {
+ LoggerConfig logger = getLogger(loggerName);
+ if (level == null) {
+ clearLogLevel(loggerName, logger);
+ } else {
+ setLogLevel(loggerName, logger, level);
+ }
+ getLoggerContext().updateLoggers();
+ }
+
+ private void clearLogLevel(String loggerName, LoggerConfig logger) {
+ if (logger instanceof LevelSetLoggerConfig) {
+ getLoggerContext().getConfiguration().removeLogger(loggerName);
+ } else {
+ logger.setLevel(null);
+ }
+ }
+
+ private void setLogLevel(String loggerName, LoggerConfig logger, Level level) {
+ if (logger == null) {
+ getLoggerContext().getConfiguration().addLogger(loggerName,
+ new LevelSetLoggerConfig(loggerName, level, true));
+ } else {
+ logger.setLevel(level);
+ }
+ }
+
+ @Override
+ public List getLoggerConfigurations() {
+ List result = new ArrayList<>();
+ getAllLoggers().forEach((name, loggerConfig) -> result.add(convertLoggerConfig(name, loggerConfig)));
+ result.sort(CONFIGURATION_COMPARATOR);
+ return result;
+ }
+
+ @Override
+ public LoggerConfiguration getLoggerConfiguration(String loggerName) {
+ LoggerConfig loggerConfig = getAllLoggers().get(loggerName);
+ return (loggerConfig != null) ? convertLoggerConfig(loggerName, loggerConfig) : null;
+ }
+
+ private Map getAllLoggers() {
+ Map loggers = new LinkedHashMap<>();
+ for (Logger logger : getLoggerContext().getLoggers()) {
+ addLogger(loggers, logger.getName());
+ }
+ getLoggerContext().getConfiguration().getLoggers().keySet().forEach((name) -> addLogger(loggers, name));
+ return loggers;
+ }
+
+ private void addLogger(Map loggers, String name) {
+ Configuration configuration = getLoggerContext().getConfiguration();
+ while (name != null) {
+ loggers.computeIfAbsent(name, configuration::getLoggerConfig);
+ name = getSubName(name);
+ }
+ }
+
+ private String getSubName(String name) {
+ if (!StringUtils.hasLength(name)) {
+ return null;
+ }
+ int nested = name.lastIndexOf('$');
+ return (nested != -1) ? name.substring(0, nested) : NameUtil.getSubName(name);
+ }
+
+ private LoggerConfiguration convertLoggerConfig(String name, LoggerConfig loggerConfig) {
+ if (loggerConfig == null) {
+ return null;
+ }
+ LevelConfiguration effectiveLevelConfiguration = getLevelConfiguration(loggerConfig
+ .getLevel());
+ if (!StringUtils.hasLength(name) || LogManager.ROOT_LOGGER_NAME.equals(name)) {
+ name = ROOT_LOGGER_NAME;
+ }
+ boolean isAssigned = loggerConfig.getName().equals(name);
+ LevelConfiguration assignedLevelConfiguration = (!isAssigned) ? null
+ : effectiveLevelConfiguration;
+ return new LoggerConfiguration(name, assignedLevelConfiguration,
+ effectiveLevelConfiguration);
+ }
+
+ private LevelConfiguration getLevelConfiguration(Level level) {
+ LogLevel logLevel = LEVELS.convertNativeToSystem(level);
+ return (logLevel != null) ? LevelConfiguration.of(logLevel) : LevelConfiguration
+ .ofCustom(level.name());
+ }
+
+ @Override
+ public Runnable getShutdownHandler() {
+ return () -> getLoggerContext().stop();
+ }
+
+ @Override
+ public void cleanUp() {
+ super.cleanUp();
+ LoggerContext loggerContext = getLoggerContext();
+ markAsUninitialized(loggerContext);
+ loggerContext.getConfiguration().removeFilter(FILTER);
+ }
+
+ private LoggerConfig getLogger(String name) {
+ boolean isRootLogger = !StringUtils.hasLength(name) || ROOT_LOGGER_NAME.equals(name);
+ return findLogger(isRootLogger ? LogManager.ROOT_LOGGER_NAME : name);
+ }
+
+ private LoggerConfig findLogger(String name) {
+ Configuration configuration = getLoggerContext().getConfiguration();
+ if (configuration instanceof AbstractConfiguration) {
+ return ((AbstractConfiguration) configuration).getLogger(name);
+ }
+ return configuration.getLoggers().get(name);
+ }
+
+ private LoggerContext getLoggerContext() {
+ return (LoggerContext) LogManager.getContext(
+ Thread.currentThread().getContextClassLoader(), false);
+ }
+
+ private boolean isAlreadyInitialized(LoggerContext loggerContext) {
+ return LoggingSystem.class.getName().equals(loggerContext.getExternalContext());
+ }
+
+ private void markAsInitialized(LoggerContext loggerContext) {
+ loggerContext.setExternalContext(LoggingSystem.class.getName());
+ }
+
+ private void markAsUninitialized(LoggerContext loggerContext) {
+ loggerContext.setExternalContext(null);
+ }
+
+ /**
+ * {@link LoggingSystemFactory} that returns {@link Log4J2LoggingSystem} if possible.
+ */
+ @Order(Ordered.LOWEST_PRECEDENCE)
+ public static class Factory implements LoggingSystemFactory {
+
+ private static final boolean PRESENT = ClassUtils
+ .isPresent(
+ "org.apache.logging.log4j.core.impl.Log4jContextFactory",
+ Factory.class.getClassLoader());
+
+ @Override
+ public LoggingSystem getLoggingSystem(ClassLoader classLoader) {
+ if (PRESENT) {
+ return new Log4J2LoggingSystem(classLoader);
+ }
+ return null;
+ }
+
+ }
+
+ /**
+ * {@link LoggerConfig} used when the user has set a specific {@link Level}.
+ */
+ private static class LevelSetLoggerConfig extends LoggerConfig {
+
+ LevelSetLoggerConfig(String name, Level level, boolean additive) {
+ super(name, level, additive);
+ }
+
+ }
+
+}
diff --git a/sofa-serverless-runtime/sofa-serverless-common/src/test/java/com/alipay/sofa/serverless/common/util/OSUtilsTest.java b/sofa-serverless-runtime/sofa-serverless-common/src/test/java/com/alipay/sofa/serverless/common/util/OSUtilsTest.java
index 470226abf..a0e60a24e 100644
--- a/sofa-serverless-runtime/sofa-serverless-common/src/test/java/com/alipay/sofa/serverless/common/util/OSUtilsTest.java
+++ b/sofa-serverless-runtime/sofa-serverless-common/src/test/java/com/alipay/sofa/serverless/common/util/OSUtilsTest.java
@@ -18,7 +18,6 @@
import org.junit.Assert;
import org.junit.Test;
-
/**
* @author CodeNoobKing
* @data 2024/1/22
@@ -40,6 +39,5 @@ public void testGetLocalFileProtocolPrefix() {
} finally {
OSUtils.OS_NAME_KEY = "os.name";
}
-
}
}