org.slf4j.Marker Java Examples

@PostConstruct
public void init() {
    log.debug("Registering JVM gauges");
    metricRegistry.register(PROP_METRIC_REG_JVM_MEMORY, new MemoryUsageGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_GARBAGE, new GarbageCollectorMetricSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_THREADS, new ThreadStatesGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_FILES, new FileDescriptorRatioGauge());
    metricRegistry.register(PROP_METRIC_REG_JVM_BUFFERS, new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer()));
    if (jHipsterProperties.getMetrics().getJmx().isEnabled()) {
        log.debug("Initializing Metrics JMX reporting");
        JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
    }
    if (jHipsterProperties.getMetrics().getLogs().isEnabled()) {
        log.info("Initializing Metrics Log reporting");
        Marker metricsMarker = MarkerFactory.getMarker("metrics");
        final Slf4jReporter reporter = Slf4jReporter.forRegistry(metricRegistry)
            .outputTo(LoggerFactory.getLogger("metrics"))
            .markWith(metricsMarker)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
        reporter.start(jHipsterProperties.getMetrics().getLogs().getReportFrequency(), TimeUnit.SECONDS);
    }
}
 

/**
 * Logs the exception; on ERROR level when status is 5xx, otherwise on INFO level without stack
 * trace, or DEBUG level with stack trace. The logger name is
 * {@code cz.jirutka.spring.exhandler.handlers.RestExceptionHandler}.
 *
 * @param ex The exception to log.
 * @param req The current web request.
 */
protected void logException(E ex, HttpServletRequest req) {

    if (LOG.isErrorEnabled() && getStatus().value() >= 500 || LOG.isInfoEnabled()) {
        Marker marker = MarkerFactory.getMarker(ex.getClass().getName());

        String uri = req.getRequestURI();
        if (req.getQueryString() != null) {
            uri += '?' + req.getQueryString();
        }
        String msg = String.format("%s %s ~> %s", req.getMethod(), uri, getStatus());

        if (getStatus().value() >= 500) {
            LOG.error(marker, msg, ex);

        } else if (LOG.isDebugEnabled()) {
            LOG.debug(marker, msg, ex);

        } else {
            LOG.info(marker, msg);
        }
    }
}
 

@PostConstruct
public void init() {
    log.debug("Registering JVM gauges");
    metricRegistry.register(PROP_METRIC_REG_JVM_MEMORY, new MemoryUsageGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_GARBAGE, new GarbageCollectorMetricSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_THREADS, new ThreadStatesGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_FILES, new FileDescriptorRatioGauge());
    metricRegistry.register(PROP_METRIC_REG_JVM_BUFFERS, new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer()));
    metricRegistry.register(PROP_METRIC_REG_JVM_ATTRIBUTE_SET, new JvmAttributeGaugeSet());
    if (jHipsterProperties.getMetrics().getJmx().isEnabled()) {
        log.debug("Initializing Metrics JMX reporting");
        JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
    }
    if (jHipsterProperties.getMetrics().getLogs().isEnabled()) {
        log.info("Initializing Metrics Log reporting");
        Marker metricsMarker = MarkerFactory.getMarker("metrics");
        final Slf4jReporter reporter = Slf4jReporter.forRegistry(metricRegistry)
            .outputTo(LoggerFactory.getLogger("metrics"))
            .markWith(metricsMarker)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
        reporter.start(jHipsterProperties.getMetrics().getLogs().getReportFrequency(), TimeUnit.SECONDS);
    }
}
 

private void getMarkersRecursively(Marker marker, ArrayComposer<JSONComposer<String>> ac) throws IOException {
    if (marker != null) {
        ac.add(marker.getName());
        Iterator<Marker> it = marker.iterator();
        while (it.hasNext()) {
            getMarkersRecursively(it.next(), ac);
        }
    }
}
 

@Override
public void doLog(Marker marker, Level level, String format, Object[] arguments, Throwable t) {
    if (!LambdaLoggerUtils.isLogLevelEnabled(underlyingLogger, level, marker)) {
        return;
    }

    if (arguments == null) {
        logFormatted(marker, level, format, t);
    } else {
        FormattingTuple formattingTuple = MessageFormatter.arrayFormat(format, arguments, t);
        logFormatted(marker, level, formattingTuple.getMessage(), formattingTuple.getThrowable());
    }
}
 

private Slf4jReporter(MetricRegistry registry,
                      LoggerProxy loggerProxy,
                      Marker marker,
                      String prefix,
                      TimeUnit rateUnit,
                      TimeUnit durationUnit,
                      MetricFilter filter) {
    super(registry, "logger-reporter", filter, rateUnit, durationUnit);
    this.loggerProxy = loggerProxy;
    this.marker = marker;
    this.prefix = MetricName.build(prefix);
}
 

@Override
public void error(Marker marker, String string, Object[] os) {
    if(isErrorEnabled(marker)) {
        log(string);
        log(os);
    }
}
 

@Override
@SafeVarargs
public final void trace(Marker marker, String format, Supplier<Object>... arguments) {
  if (logger.isTraceEnabled(marker)) {
    logger.trace(marker, format, Arrays.stream(arguments).map(Supplier::get).toArray());
  }
}
 

@PostConstruct
public void init() {
    log.debug("Registering JVM gauges");
    metricRegistry.register(PROP_METRIC_REG_JVM_MEMORY, new MemoryUsageGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_GARBAGE, new GarbageCollectorMetricSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_THREADS, new ThreadStatesGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_FILES, new FileDescriptorRatioGauge());
    metricRegistry.register(PROP_METRIC_REG_JVM_BUFFERS, new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer()));
    metricRegistry.register(PROP_METRIC_REG_JVM_ATTRIBUTE_SET, new JvmAttributeGaugeSet());
    if (hikariDataSource != null) {
        log.debug("Monitoring the datasource");
        // remove the factory created by HikariDataSourceMetricsPostProcessor until JHipster migrate to Micrometer
        hikariDataSource.setMetricsTrackerFactory(null);
        hikariDataSource.setMetricRegistry(metricRegistry);
    }
    if (jHipsterProperties.getMetrics().getJmx().isEnabled()) {
        log.debug("Initializing Metrics JMX reporting");
        JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
    }
    if (jHipsterProperties.getMetrics().getLogs().isEnabled()) {
        log.info("Initializing Metrics Log reporting");
        Marker metricsMarker = MarkerFactory.getMarker("metrics");
        final Slf4jReporter reporter = Slf4jReporter.forRegistry(metricRegistry)
            .outputTo(LoggerFactory.getLogger("metrics"))
            .markWith(metricsMarker)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
        reporter.start(jHipsterProperties.getMetrics().getLogs().getReportFrequency(), TimeUnit.SECONDS);
    }
}
 

@Override
public void info(final Marker marker, final String format, final Object... arguments) {
    if (isInfoEnabled(marker)) {
        putCorrelationIdToMdc();
        actualSlf4jLogger.info(marker, format, arguments);
    }
}
 

@Override
public void errorIfEnabled(Marker marker, String msg) {
    if (logger.isErrorEnabled()) {
        logger.error(marker, msg);
    }

}
 

@Test
public void testLocationAwareLogger() {
    LocationAwareLogger locationAwareLogger = mock(LocationAwareLogger.class);
    Slf4jLogger logger = new Slf4jLogger(locationAwareLogger);

    logger.error("error");
    ;

    logger.warn("warn");
    logger.info("info");
    logger.debug("debug");
    logger.trace("info");

    verify(locationAwareLogger, times(5)).log(isNull(Marker.class), anyString(),
            anyInt(), anyString(), isNull(Object[].class), isNull(Throwable.class));

    logger.error(new Exception("error"));
    logger.warn(new Exception("warn"));
    logger.info(new Exception("info"));
    logger.debug(new Exception("debug"));
    logger.trace(new Exception("trace"));

    logger.error("error", new Exception("error"));
    logger.warn("warn", new Exception("warn"));
    logger.info("info", new Exception("info"));
    logger.debug("debug", new Exception("debug"));
    logger.trace("trace", new Exception("trace"));

    verify(locationAwareLogger, times(10)).log(isNull(Marker.class), anyString(),
            anyInt(), anyString(), isNull(Object[].class), any(Throwable.class));
}
 

@Override
public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) {
    if (loggerName == null) {
        return FilterReply.NEUTRAL;
    } else if (loggerName.equals(logger.getName())) {
        return FilterReply.DENY;
    } else
        return FilterReply.NEUTRAL;
}
 

@Override
public void debug(Marker marker, String format, Object arg1, Object arg2) {
    if (isDebugEnabled(marker) && canDo()) {
        if (locationAwareLogger != null) {
            locationAwareLogger.log(marker, FQCN, DEBUG_INT, msg(format),
                    args(new Object[]{arg1, arg2}), null);
        } else {
            logger.debug(marker, msg(format), args(new Object[]{arg1, arg2}));
        }
    }
}
 

@Override
public void infoIfEnabled(Marker marker, String msg, Throwable t) {
    if (logger.isInfoEnabled()) {
        logger.info(marker, msg, t);
    }

}
 

@Override
public void trace(final Marker marker, final String s) {
    logger.logIfEnabled(FQCN, Level.TRACE, getMarker(marker), s);
}
 

@Override
public void error(Marker marker, String msg) {
    if (log.isErrorEnabled(marker)) {
        log.error(marker, msg);
    }
}
 

@Override
public boolean isTraceEnabled(Marker marker) {
    return logger.isTraceEnabled(marker);
}
 

@Override
public void warn(Marker arg0, String arg1, Object arg2) {
  if (isLoggable(Level.WARNING, arg0) && isNotLimited(Level.WARNING)) {
    log2(arg0, fqcnCmn, Level.WARNING, arg1, new Object[] { arg2 }, null);
  }
}
 

@Override
public void log(Marker marker, String fqcn, int level, String message, Object[] arguments, Throwable t) {
    underlyingLogger.log(marker, fqcn, level, message, arguments, t);
}
 

@Override
public void trace(Marker marker, String msg, Throwable t) {
  delegate.trace(marker, msg, t);
}
 

@Override
public boolean isTraceEnabled(Marker marker) {
    return logger.isTraceEnabled(marker);
}
 

public void error(Marker marker, String msg) {
	if (getLevel() <= LocationAwareLogger.ERROR_INT) {
		delegate.error(marker, msg);
	}
}
 

@Override
public void error(final Marker marker, final String format, final Object arg1, final Object arg2) {
    if (isErrorEnabled(marker)) {
        __doBuildEx(__getSafeMessages(format, arg1, arg2), null, LogLevel.ERROR);
    }
}
 

@Override
public void debug(Marker marker, String msg) {
    Log.d(tag, msg);
}
 

@SuppressWarnings("unchecked")
private static void modifyCassandraYaml(
    @NotNull final Marker taskIdMarker,
    @NotNull final String version,
    @NotNull final CassandraServerConfig cassandraServerConfig
) throws IOException {
    LOGGER.info(taskIdMarker, "Building cassandra.yaml");

    final File cassandraYaml = new File("apache-cassandra-" + version + "/conf/cassandra.yaml");

    final Yaml yaml = new Yaml();
    final Map<String, Object> yamlMap;
    LOGGER.info(taskIdMarker, "Reading cassandra.yaml");
    try (BufferedReader br = new BufferedReader(new FileReader(cassandraYaml))) {
        yamlMap = (Map<String, Object>) yaml.load(br);
    }
    LOGGER.info(taskIdMarker, "Modifying cassandra.yaml");
    for (final TaskConfig.Entry entry : cassandraServerConfig.getCassandraYamlConfig().getVariablesList()) {
        switch (entry.getName()) {
            case "seeds":
                final List<Map<String, Object>> seedProviderList = (List<Map<String, Object>>) yamlMap.get("seed_provider");
                final Map<String, Object> seedProviderMap = seedProviderList.get(0);
                final List<Map<String, Object>> parameters = (List<Map<String, Object>>) seedProviderMap.get("parameters");
                final Map<String, Object> parametersMap = parameters.get(0);
                parametersMap.put("seeds", entry.getStringValue());
                break;
            default:
                if (entry.hasStringValue()) {
                    yamlMap.put(entry.getName(), entry.getStringValue());
                } else if (entry.hasLongValue()) {
                    yamlMap.put(entry.getName(), entry.getLongValue());
                } else if (!entry.getStringValuesList().isEmpty()) {
                    yamlMap.put(entry.getName(), entry.getStringValuesList());
                }
        }
    }
    if (LOGGER.isDebugEnabled()) {
        final StringWriter sw = new StringWriter();
        yaml.dump(yamlMap, sw);
        LOGGER.debug("cassandra.yaml result: {}", sw);
    }
    LOGGER.info(taskIdMarker, "Writing cassandra.yaml");
    try (BufferedWriter bw = new BufferedWriter(new FileWriter(cassandraYaml))) {
        yaml.dump(yamlMap, bw);
    }
}
 

@Override
public void debug(Marker marker, String msg, Throwable t) {
    log.debug(marker, msg, t);
}
 

public boolean isTraceEnabled(Marker marker) {
    return logger.isTraceEnabled(marker);
}
 

@Override
public boolean isInfoEnabled(Marker marker) {
    return logger.isInfoEnabled();
}
 

@Override
public boolean isTraceEnabled(Marker marker) {
    return logger.isTraceEnabled(marker);
}