下面列出了org.springframework.boot.logging.LogFile#org.apache.logging.log4j.core.config.Configuration 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private EcsLayout(Configuration config, String serviceName, String eventDataset, boolean includeMarkers, KeyValuePair[] additionalFields, boolean includeOrigin, boolean stackTraceAsArray) {
super(config, UTF_8, null, null);
this.serviceName = serviceName;
this.eventDataset = eventDataset;
this.includeMarkers = includeMarkers;
this.includeOrigin = includeOrigin;
this.stackTraceAsArray = stackTraceAsArray;
this.additionalFields = additionalFields;
fieldValuePatternFormatter = new PatternFormatter[additionalFields.length][];
for (int i = 0; i < additionalFields.length; i++) {
KeyValuePair additionalField = additionalFields[i];
if (additionalField.getValue().contains("%")) {
fieldValuePatternFormatter[i] = PatternLayout.createPatternParser(config)
.parse(additionalField.getValue())
.toArray(new PatternFormatter[0]);
}
}
}
public static Configuration addTestFixtures(final String name, final ConfigurationBuilder<BuiltConfiguration> builder) {
builder.setConfigurationName(name);
builder.setStatusLevel(Level.ERROR);
builder.add(builder.newScriptFile("target/test-classes/scripts/filter.groovy").addIsWatched(true));
builder.add(builder.newFilter("ThresholdFilter", Filter.Result.ACCEPT, Filter.Result.NEUTRAL)
.addAttribute("level", Level.DEBUG));
final AppenderComponentBuilder appenderBuilder = builder.newAppender("Stdout", "CONSOLE").addAttribute("target", ConsoleAppender.Target.SYSTEM_OUT);
appenderBuilder.add(builder.
newLayout("PatternLayout").
addAttribute("pattern", "%d [%t] %-5level: %msg%n%throwable"));
appenderBuilder.add(builder.
newFilter("MarkerFilter", Filter.Result.DENY, Filter.Result.NEUTRAL).
addAttribute("marker", "FLOW"));
builder.add(appenderBuilder);
builder.add(builder.newLogger("org.apache.logging.log4j", Level.DEBUG, true).
add(builder.newAppenderRef("Stdout")).
addAttribute("additivity", false));
builder.add(builder.newRootLogger(Level.ERROR).add(builder.newAppenderRef("Stdout")));
builder.add(builder.newCustomLevel("Panic", 17));
return builder.build();
}
/**
* Directly test the methods in the {@link LogLevel} annotation class
*/
@LogLevel("org.apache.solr.bogus_logger.MethodLogLevel=TRACE")
public void testWhiteBoxMethods() {
final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
final Configuration config = ctx.getConfiguration();
final Map<String,Level> oldLevels = LogLevel.Configurer.setLevels(bogus_logger_prefix + "=TRACE");
//
assertEquals(oldLevels.toString(), 1, oldLevels.size());
assertNull(oldLevels.get(bogus_logger_prefix));
//
assertEquals(Level.TRACE, config.getLoggerConfig(bogus_logger_prefix).getLevel());
assertEquals(Level.TRACE, LogManager.getLogger(bogus_logger_prefix).getLevel());
// restore (to 'unset' values)...
LogLevel.Configurer.restoreLogLevels(oldLevels);
assertEquals(bogus_logger_prefix
+ " should have had it's config unset; should now return the 'root' LoggerConfig",
config.getRootLogger(),
config.getLoggerConfig(bogus_logger_prefix));
assertEquals(DEFAULT_LOG_LEVEL, LogManager.getLogger(bogus_logger_prefix).getLevel());
}
private static Logger configureLog4j() {
LoggerContext context = (LoggerContext) LogManager.getContext();
Configuration config = context.getConfiguration();
PatternLayout layout = PatternLayout.createLayout("%m%n", null, null, Charset.defaultCharset(), false, false, null, null);
Appender appender = ConsoleAppender.createAppender(layout, null, null, "CONSOLE_APPENDER", null, null);
appender.start();
AppenderRef ref = AppenderRef.createAppenderRef("CONSOLE_APPENDER", null, null);
AppenderRef[] refs = new AppenderRef[]{ref};
LoggerConfig loggerConfig = LoggerConfig.createLogger("false", Level.INFO, "CONSOLE_LOGGER", "com", refs, null, null, null);
loggerConfig.addAppender(appender, null, null);
config.addAppender(appender);
config.addLogger("Main.class", loggerConfig);
context.updateLoggers(config);
return LogManager.getContext().getLogger("Main.class");
}
@PluginFactory
public static CustomJsonLayout createLayout(@PluginConfiguration final Configuration config,
@PluginAttribute(value = "locationInfo", defaultBoolean = false) final boolean locationInfo,
@PluginAttribute(value = "properties", defaultBoolean = false) final boolean properties,
@PluginAttribute(value = "propertiesAsList", defaultBoolean = false) final boolean propertiesAsList,
@PluginAttribute(value = "complete", defaultBoolean = false) final boolean complete,
@PluginAttribute(value = "compact", defaultBoolean = false) final boolean compact,
@PluginAttribute(value = "eventEol", defaultBoolean = false) final boolean eventEol,
@PluginAttribute(value = "header", defaultString = DEFAULT_HEADER) final String headerPattern,
@PluginAttribute(value = "footer", defaultString = DEFAULT_FOOTER) final String footerPattern,
@PluginAttribute(value = "charset", defaultString = "UTF-8") final Charset charset,
@PluginAttribute(value = "includeStacktrace", defaultBoolean = true) final boolean includeStacktrace,
@PluginAttribute(value = "stacktraceAsString", defaultBoolean = false) final boolean stacktraceAsString,
@PluginAttribute(value = "objectMessageAsJsonObject",
defaultBoolean = false) final boolean objectMessageAsJsonObject) {
final boolean encodeThreadContextAsList = properties && propertiesAsList;
return new CustomJsonLayout(config, locationInfo, properties, encodeThreadContextAsList, complete, compact,
eventEol, headerPattern, footerPattern, charset, includeStacktrace, stacktraceAsString,
objectMessageAsJsonObject);
}
/**
* Validates that the code pattern we use to add an appender on the fly
* works with a basic appender that is not the new OutputStream appender or
* new Writer appender.
*/
@Test
public void testUpdatePatternWithFileAppender() {
final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
final Configuration config = ctx.getConfiguration();
// @formatter:off
final Appender appender = FileAppender.newBuilder()
.setFileName("target/" + getClass().getName() + ".log")
.setAppend(false)
.setName("File")
.setIgnoreExceptions(false)
.setBufferedIo(false)
.setBufferSize(4000)
.setConfiguration(config)
.build();
// @formatter:on
appender.start();
config.addAppender(appender);
ConfigurationTestUtils.updateLoggers(appender, config);
LogManager.getLogger().error("FOO MSG");
}
public static void setLevel(Level level) {
LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
Configuration config = ctx.getConfiguration();
LoggerConfig loggerConfig = config.getLoggerConfig(LogManager.ROOT_LOGGER_NAME);
loggerConfig.setLevel(level);
ctx.updateLoggers();
if (level == Level.ERROR) {
logger.error("<- This level is successfully initialized");
}
if (level == Level.WARN) {
logger.warn("<- This level is successfully initialized");
}
if (level == Level.DEBUG) {
logger.debug("<- This level is successfully initialized");
}
if (level == Level.INFO) {
logger.info("<- This level is successfully initialized");
}
}
@Test
void testSoutJsonTempJson() {
Configuration configuration = getLogConfig(Map.of("log_format_sout", "json"));
assertThat(configuration.getAppenders().values()).hasSize(2);
Optional<ConsoleAppender> consoleAppender = configuration.getAppenders().values().stream()
.filter(ConsoleAppender.class::isInstance)
.map(ConsoleAppender.class::cast)
.findAny();
assertThat(consoleAppender).isNotEmpty();
assertThat(consoleAppender.get().getLayout()).isInstanceOf(EcsLayout.class);
Optional<RollingFileAppender> fileAppender = configuration.getAppenders().values().stream()
.filter(RollingFileAppender.class::isInstance)
.map(RollingFileAppender.class::cast)
.findAny();
assertThat(fileAppender).isNotEmpty();
assertThat(fileAppender.get().getLayout()).isInstanceOf(EcsLayout.class);
}
@Test(expected = ConfigurationException.class)
public void throwsExceptionOnUnresolvedAppender() {
// given
Appender appender = mock(Appender.class);
when(appender.isStarted()).thenReturn(true);
Configuration configuration = mock(Configuration.class);
String testAppenderRef = "testAppenderRef";
when(configuration.getAppender(testAppenderRef)).thenReturn(null);
FailoverPolicy<String> failoverPolicy = createTestFailoverPolicy(testAppenderRef, configuration);
String failedMessage = "test failed message";
// when
failoverPolicy.deliver(failedMessage);
}
private static StringWriter addWriterAppender(final LoggerContext context, Level level) {
final Configuration config = context.getConfiguration();
final StringWriter writer = new StringWriter();
final Map.Entry<String, Appender> existing = config.getAppenders().entrySet().iterator().next();
final WriterAppender writerAppender = WriterAppender.newBuilder()
.setName(APPENDER_NAME)
.setLayout(existing.getValue().getLayout())
.setTarget(writer)
.build();
writerAppender.start();
config.getRootLogger().addAppender(writerAppender, level, null);
return writer;
}
@Test
public void testAsyncProperties() throws Exception {
LoggerContext loggerContext = configure("target/test-classes/log4j1-async.properties");
Logger logger = LogManager.getLogger("test");
logger.debug("This is a test of the root logger");
Thread.sleep(50);
Configuration configuration = loggerContext.getConfiguration();
Map<String, Appender> appenders = configuration.getAppenders();
ListAppender messageAppender = null;
for (Map.Entry<String, Appender> entry : appenders.entrySet()) {
if (entry.getKey().equals("list")) {
messageAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
}
}
assertNotNull("No Message Appender", messageAppender);
List<String> messages = messageAppender.getMessages();
assertTrue("No messages", messages != null && messages.size() > 0);
}
@Test
public void resolvesAppenderRefOnlyOnce() {
// given
Appender appender = mock(Appender.class);
when(appender.isStarted()).thenReturn(true);
Configuration configuration = mock(Configuration.class);
String testAppenderRef = "testAppenderRef";
when(configuration.getAppender(testAppenderRef)).thenReturn(appender);
FailoverPolicy<String> failoverPolicy = createTestFailoverPolicy(testAppenderRef, configuration);
String failedMessage = "test failed message";
// when
failoverPolicy.deliver(failedMessage);
failoverPolicy.deliver(failedMessage);
// then
verify(configuration, times(1)).getAppender(anyString());
verify(appender, times(2)).append(any(LogEvent.class));
}
private LoggerContext configure(String configLocation) throws Exception {
File file = new File(configLocation);
InputStream is = new FileInputStream(file);
ConfigurationSource source = new ConfigurationSource(is, file);
LoggerContextFactory factory = org.apache.logging.log4j.LogManager.getFactory();
LoggerContext context = (LoggerContext) org.apache.logging.log4j.LogManager.getContext(false);
Configuration configuration;
if (configLocation.endsWith(".xml")) {
configuration = new XmlConfigurationFactory().getConfiguration(context, source);
} else {
configuration = new PropertiesConfigurationFactory().getConfiguration(context, source);
}
assertNotNull("No configuration created", configuration);
Configurator.reconfigure(configuration);
return context;
}
@Test
public void testProgrammaticConfig() {
LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
Configuration config = ctx.getConfiguration();
PatternLayout layout = PatternLayout.newBuilder().withConfiguration(config).withPattern("%d{HH:mm:ss.SSS} %level %msg%n").build();
Appender appender = FileAppender.newBuilder().setConfiguration(config).withName("programmaticFileAppender").withLayout(layout).withFileName("java.log").build();
appender.start();
config.addAppender(appender);
AppenderRef ref = AppenderRef.createAppenderRef("programmaticFileAppender", null, null);
AppenderRef[] refs = new AppenderRef[] { ref };
LoggerConfig loggerConfig = LoggerConfig.createLogger(false, Level.INFO, "programmaticLogger", "true", refs, null, config, null);
loggerConfig.addAppender(appender, null, null);
config.addLogger("programmaticLogger", loggerConfig);
ctx.updateLoggers();
Logger pLogger = LogManager.getLogger("programmaticLogger");
pLogger.info("Programmatic Logger Message");
}
private static void addFileAppender(String logFilename) throws IOException {
File logFile = new File(logFilename);
Object ctx = LogManager.getContext(false);
if (ctx instanceof LoggerContext) {
try (LoggerContext context = (LoggerContext) ctx) {
Configuration configuration = context.getConfiguration();
LoggerConfig loggerConfig = configuration.getLoggerConfig(LogManager.ROOT_LOGGER_NAME);
FileAppender fileAppender =
FileAppender.newBuilder()
.setName("file")
.setLayout(
PatternLayout.newBuilder()
.withPattern("[%d][%-5.-5p][%-14.-14c{1}:%4L] %-22.-22M - %m%n")
.build())
.withFileName(logFile.getCanonicalPath())
.build();
configuration.addAppender(fileAppender);
loggerConfig.addAppender(fileAppender, Level.ERROR, null);
context.updateLoggers();
}
}
}
private void testDailyRollingFileAppender(final String configResource, final String name, final String filePattern) throws URISyntaxException {
final Configuration configuration = getConfiguration(configResource);
final Appender appender = configuration.getAppender(name);
assertNotNull(appender);
assertEquals(name, appender.getName());
assertTrue(appender.getClass().getName(), appender instanceof RollingFileAppender);
final RollingFileAppender rfa = (RollingFileAppender) appender;
assertEquals("target/hadoop.log", rfa.getFileName());
assertEquals(filePattern, rfa.getFilePattern());
final TriggeringPolicy triggeringPolicy = rfa.getTriggeringPolicy();
assertNotNull(triggeringPolicy);
assertTrue(triggeringPolicy.getClass().getName(), triggeringPolicy instanceof CompositeTriggeringPolicy);
final CompositeTriggeringPolicy ctp = (CompositeTriggeringPolicy) triggeringPolicy;
final TriggeringPolicy[] triggeringPolicies = ctp.getTriggeringPolicies();
assertEquals(1, triggeringPolicies.length);
final TriggeringPolicy tp = triggeringPolicies[0];
assertTrue(tp.getClass().getName(), tp instanceof TimeBasedTriggeringPolicy);
final TimeBasedTriggeringPolicy tbtp = (TimeBasedTriggeringPolicy) tp;
assertEquals(1, tbtp.getInterval());
final RolloverStrategy rolloverStrategy = rfa.getManager().getRolloverStrategy();
assertTrue(rolloverStrategy.getClass().getName(), rolloverStrategy instanceof DefaultRolloverStrategy);
final DefaultRolloverStrategy drs = (DefaultRolloverStrategy) rolloverStrategy;
assertEquals(Integer.MAX_VALUE, drs.getMaxIndex());
configuration.start();
configuration.stop();
}
private static Logger configureLog4j() {
LoggerContext context = (LoggerContext) LogManager.getContext();
Configuration config = context.getConfiguration();
PatternLayout layout = PatternLayout.createLayout("%m%n", null, null, Charset.defaultCharset(), false, false, null, null);
Appender appender = ConsoleAppender.createAppender(layout, null, null, "CONSOLE_APPENDER", null, null);
appender.start();
AppenderRef ref = AppenderRef.createAppenderRef("CONSOLE_APPENDER", null, null);
AppenderRef[] refs = new AppenderRef[]{ref};
LoggerConfig loggerConfig = LoggerConfig.createLogger("false", Level.INFO, "CONSOLE_LOGGER", "com", refs, null, null, null);
loggerConfig.addAppender(appender, null, null);
config.addAppender(appender);
config.addLogger("Main.class", loggerConfig);
context.updateLoggers(config);
return LogManager.getContext().getLogger("Main.class");
}
/**
* Deprecated, use {@link #newBuilder()} instead.
* @param properties
* @param defaultPattern
* @param alwaysWriteExceptions
* @param noConsoleNoAnsi
* @param configuration
* @return a new MarkerPatternSelector.
* @deprecated Use {@link #newBuilder()} instead.
*/
@Deprecated
public static LevelPatternSelector createSelector(
final PatternMatch[] properties,
final String defaultPattern,
final boolean alwaysWriteExceptions,
final boolean noConsoleNoAnsi,
final Configuration configuration) {
final Builder builder = newBuilder();
builder.setProperties(properties);
builder.setDefaultPattern(defaultPattern);
builder.setAlwaysWriteExceptions(alwaysWriteExceptions);
builder.setNoConsoleNoAnsi(noConsoleNoAnsi);
builder.setConfiguration(configuration);
return builder.build();
}
private Layout<?> testFile(final String configResource) throws Exception {
final Configuration configuration = getConfiguration(configResource);
final FileAppender appender = configuration.getAppender("File");
assertNotNull(appender);
assertEquals("target/mylog.txt", appender.getFileName());
//
final LoggerConfig loggerConfig = configuration.getLoggerConfig("com.example.foo");
assertNotNull(loggerConfig);
assertEquals(Level.DEBUG, loggerConfig.getLevel());
configuration.start();
configuration.stop();
return appender.getLayout();
}
@Override
public Configuration getConfiguration(final LoggerContext loggerContext, final ConfigurationSource source) {
if (!isActive) {
return null;
}
return new JsonConfiguration(loggerContext, source);
}
/**
* Extracts the {@link LogPanelAppender} from the root logger configuration
* and hands an instance of this panel to it.
*/
private void addLogAppender() {
LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
Configuration config = ctx.getConfiguration();
LogPanelAppender logAppender = config.getAppender("logPanel");
if (logAppender == null) {
Msg.error(this, "Couldn't find LogPanelAppender instance in the Log4j context; " +
"nothing will be logged to the application's Front-end panel.");
return;
}
logAppender.setLogListener(this);
}
protected AbstractJacksonLayout(final Configuration config, final ObjectWriter objectWriter, final Charset charset,
final boolean compact, final boolean complete, final boolean eventEol, final Serializer headerSerializer,
final Serializer footerSerializer) {
super(config, charset, headerSerializer, footerSerializer);
this.objectWriter = objectWriter;
this.compact = compact;
this.complete = complete;
this.eol = compact && !eventEol ? COMPACT_EOL : DEFAULT_EOL;
}
public static void main(String[] args) throws Exception{
LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
Configuration config = ctx.getConfiguration();
LoggerConfig loggerConfig = config.getLoggerConfig(LogManager.ROOT_LOGGER_NAME);
loggerConfig.setLevel(Level.OFF);
ctx.updateLoggers();
test3();
}
@Test
public void testWithConfigProp() {
System.setProperty(ConfigurationFactory.CONFIGURATION_FILE_PROPERTY, CONFIG);
System.setProperty("log4j.level", "warn");
try {
final LoggerContext ctx = LoggerContext.getContext();
ctx.reconfigure();
final Configuration config = ctx.getConfiguration();
assertTrue("Configuration is not an XmlConfiguration", config instanceof XmlConfiguration);
} finally {
System.clearProperty("log4j.level");
}
}
/**
* Causes all Logger to be updated against the specified Configuration.
*
* @param config The Configuration.
*/
public void updateLoggers(final Configuration config) {
final Configuration old = this.configuration;
for (final Logger logger : loggerRegistry.getLoggers()) {
logger.updateConfiguration(config);
}
firePropertyChangeEvent(new PropertyChangeEvent(this, PROPERTY_CONFIG, old, config));
}
public Configuration getConfiguration() {
ConfigurationBuilder<BuiltConfiguration> builder = newConfigurationBuilder();
builder.setStatusLevel(Level.ERROR)
.setConfigurationName("ElasticAPM");
Level level = Level.valueOf(getValue(LOG_LEVEL_KEY, sources, getValue(DEPRECATED_LOG_LEVEL_KEY, sources, Level.INFO.toString())));
RootLoggerComponentBuilder rootLogger = builder.newRootLogger(level);
List<AppenderComponentBuilder> appenders = createAppenders(builder);
for (AppenderComponentBuilder appender : appenders) {
rootLogger.add(builder.newAppenderRef(appender.getName()));
}
builder.add(rootLogger);
return builder.build();
}
@Test
void testLogFilePlainText(@TempDir Path tempDir) {
String logFile = tempDir.resolve("agent.log").toString();
Configuration configuration = getLogConfig(Map.of("log_file", logFile));
assertThat(configuration.getAppenders().values()).hasSize(1);
Appender appender = configuration.getAppenders().values().iterator().next();
assertThat(appender).isInstanceOf(RollingFileAppender.class);
assertThat(((RollingFileAppender) appender).getFileName()).isEqualTo(logFile);
assertThat(appender.getLayout()).isInstanceOf(PatternLayout.class);
}
/**
* Configure a logger.
* @param builder
* @param name
* @param level
* @param includeLocation
*/
public DefaultLoggerComponentBuilder(final DefaultConfigurationBuilder<? extends Configuration> builder, final String name,
final String level, final boolean includeLocation) {
super(builder, name, "Logger");
if (level != null) {
addAttribute("level", level);
}
addAttribute("includeLocation", includeLocation);
}
@Test
public void whenLoggerEmitsLoggingEvent_thenAppenderReceivesEvent() throws Exception {
logger.error("Error log message from {}", this.getClass()
.getSimpleName());
LoggerContext context = LoggerContext.getContext(false);
Configuration config = context.getConfiguration();
MapAppender appender = config.getAppender("MapAppender");
assertEquals(appender.getEventMap()
.size(), 1);
}
private Configuration getLogConfig(Map<String, String> config) {
return new Log4j2ConfigurationFactory(List.of(new AbstractConfigurationSource() {
@Override
public String getValue(String key) {
return config.get(key);
}
@Override
public String getName() {
return config.toString();
}
}), "ephemeralId").getConfiguration();
}