下面列出了怎么用org.slf4j.LoggerFactory的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* Dynamically remove given topic partition from the set of assigned topic partitions.
*
* @param tp topic partition to remove
*/
default CompletableFuture<Void> removeTopicParition(TopicPartition tp) {
Objects.requireNonNull(tp);
Logger log = LoggerFactory.getLogger(DynamicAssignment.class);
log.info("Removing topic-partition: {}", tp);
return submit(consumer -> {
Set<TopicPartition> oldTps = consumer.assignment();
Set<TopicPartition> newTps = new HashSet<>(oldTps);
newTps.remove(tp);
if (!oldTps.equals(newTps)) {
log.info("Reassigning topic-partition(s): {} -> {}", oldTps, newTps);
consumer.assign(newTps);
}
return null;
});
}
@Override
public void init() {
LoggerContext loggerContext = (LoggerContext)LoggerFactory.getILoggerFactory();
if (loggerContext == null)
return;
List<Logger> loggerList = loggerContext.getLoggerList();
ch.qos.logback.classic.Logger loggerKafka =
loggerContext.getLogger("org.apache.kafka.clients.producer.ProducerConfig");
if (loggerKafka != null) {
loggerKafka.setLevel(ch.qos.logback.classic.Level.ERROR);
}
createBizLogger();
for (Logger logger : loggerList) {
AppenderAttachable appenderAttachable = logger;
setLayout(loggerContext,appenderAttachable.iteratorForAppenders());
}
}
public static void main(String[] args) {
int loopTimes = 200;
class Runner implements Runnable {
private Logger logger = LoggerFactory.getLogger(Runner.class);
@Override
public void run() {
HtmlMakerFactory factory = HtmlMakerFactory.instance();
logger.info("factory={},currentThread={}", (factory != null ? factory.getClass().getName() : "null"), Thread.currentThread().getName());
}
}
for (int i = 0; i < loopTimes; i++) {
new Thread(new Runner()).start();
}
}
/**
* Test that all of {@link OzoneManagerProtocolProtos.Type} enum values are
* categorized in {@link OmUtils#isReadOnly(OMRequest)}.
*/
@Test
public void testIsReadOnlyCapturesAllCmdTypeEnums() throws Exception {
GenericTestUtils.LogCapturer logCapturer = GenericTestUtils.LogCapturer
.captureLogs(LoggerFactory.getLogger(OmUtils.class));
OzoneManagerProtocolProtos.Type[] cmdTypes =
OzoneManagerProtocolProtos.Type.values();
for (OzoneManagerProtocolProtos.Type cmdtype : cmdTypes) {
OMRequest request = OMRequest.newBuilder()
.setCmdType(cmdtype)
.setClientId(clientId)
.build();
OmUtils.isReadOnly(request);
assertFalse(cmdtype + " is not categorized in " +
"OmUtils#isReadyOnly",
logCapturer.getOutput().contains("CmdType " + cmdtype +" is not " +
"categorized as readOnly or not."));
logCapturer.clearOutput();
}
}
@SuppressWarnings("unused")
private List<String> toQueryTermString(String field, String str) {
List<String> result = new ArrayList<>();
try {
TokenStream stream = analyzerFactory.getQueryAnalyzer().tokenStream(field,
new StringReader(str));
stream.reset();
while (stream.incrementToken()) {
result.add(stream.getAttribute(CharTermAttribute.class).toString()
.replaceAll("^term\\=", ""));
}
stream.close();
} catch (IOException e) {
LoggerFactory.getLogger(AnalyzerFactoryTestCase.class)
.error("Error during Token processing.", e);
}
return result;
}
@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);
}
}
@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 AccessLogHandler createAccessLogHandler(HttpHandler handler) {
Logger logger = LoggerFactory.getLogger("accesslog");
try {
/*
ref nginx log format:
'$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
*/
AccessLogReceiver accessLogReceiver = logger::info;
String formatString = "%h %l %u [%t] \"%r\" %s %b \"%{i,Referer}\""
+ " \"%{i,User-Agent}\" \"%{i,X-Forwarded-For}\" %D";
return new AccessLogHandler(handler, accessLogReceiver, formatString,
Undertow.class.getClassLoader());
} catch (Exception ex) {
throw new IllegalStateException("Failed to create AccessLogHandler", ex);
}
}
private ExceptionMetadata logException(Object handler, HttpServletRequest request, Exception exception) {
ExceptionMetadata exceptionMetadata = new ExceptionMetadata();
try {
buildExceptionMetadata(exceptionMetadata, handler, request);
if (exceptionMetadata.isHandlerMethod()) {
Logger logger = LoggerFactory.getLogger(exceptionMetadata.getBeanType());
logger.error("Error id is :" + exceptionMetadata.getErrorId());
logger.error("RequestMapping is:");
logger.error(exceptionMetadata.getRequestMapping());
logger.error("HandlerMethod is:");
logger.error(exceptionMetadata.getMethodName());
logger.error("ParameterMap is:");
logger.error(exceptionMetadata.getParameterMap(), exception);
} else {
log.error(handler + " execute failed, error id is:" + exceptionMetadata.getErrorId(), exception);
}
} catch (Exception e) {
log.error(handler + " execute failed.", exception);
}
return exceptionMetadata;
}
private FileAppender<ILoggingEvent> addAppender(final String file) {
final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
final PatternLayoutEncoder ple = new PatternLayoutEncoder();
ple.setPattern("%date %level [%file:%line] %msg%n");
ple.setContext(lc);
ple.start();
final FileAppender<ILoggingEvent> appender;
appender = new FileAppender<>();
appender.setFile(file);
appender.setEncoder(ple);
appender.setContext(lc);
final ThresholdFilter levelFilter = new ThresholdFilter();
levelFilter.setLevel(this.level.levelStr);
levelFilter.start();
appender.addFilter(levelFilter);
appender.start();
final ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
logbackLogger.addAppender(appender);
return appender;
}
/**
* Handle the supplied annotation introspection exception.
* it will simply be thrown, allowing it to propagate to the caller, and
* nothing will be logged.
* <p>Otherwise, this method logs an introspection failure (in particular
* {@code TypeNotPresentExceptions}) before moving on, assuming nested
* Class values were not resolvable within annotation attributes and
* thereby effectively pretending there were no annotations on the specified
* element.
*
* @param element the element that we tried to introspect annotations on
* @param ex the exception that we encountered
* @see #rethrowAnnotationConfigurationException
*/
static void handleIntrospectionFailure(AnnotatedElement element, Throwable ex) {
rethrowAnnotationConfigurationException(ex);
Logger loggerToUse = logger;
if (loggerToUse == null) {
loggerToUse = LoggerFactory.getLogger(AnnotationUtils.class);
logger = loggerToUse;
}
if (element instanceof Class && Annotation.class.isAssignableFrom((Class<?>) element)) {
// Meta-annotation lookup on an annotation type
if (loggerToUse.isDebugEnabled()) {
loggerToUse.debug("Failed to introspect meta-annotations on [" + element + "]: " + ex);
}
} else {
// Direct annotation lookup on regular Class, Method, Field
if (loggerToUse.isInfoEnabled()) {
loggerToUse.info("Failed to introspect annotations on [" + element + "]: " + ex);
}
}
}
@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);
}
}
@Before
public void init(){
this.context = new SimpleContext(UUID.randomUUID(), this.source, LoggerFactory.getLogger(TestForEachActionTemplate.class));
SimpleModel model = new SimpleModel();
model.setAttribute(Capability.ATTR_ID, modelAddress.toString());
model.setAttribute(Capability.ATTR_TYPE, DeviceCapability.NAMESPACE);
model.setAttribute(Capability.ATTR_ADDRESS, modelAddress.getRepresentation());
context.putModel(model);
logTemplate = new LogTemplate();
logTemplate.setMessage(TemplatedValue.text("hello ${value}"));
template = new ForEachModelTemplate(ImmutableSet.<String>of("address"));
template.setActions(ImmutableList.of(logTemplate,logTemplate));
template.setQuery(new TemplatedExpression(modelQuery));
template.setVar("address");
}
@Override
public void execute(final NodeExecutor nodeExecutor, final boolean isLeader, final KVStoreClosure closure) {
final Timer.Context timeCtx = getTimeContext("EXECUTE");
try {
if (nodeExecutor != null) {
nodeExecutor.execute(Status.OK(), isLeader);
}
setSuccess(closure, Boolean.TRUE);
} catch (final Exception e) {
final Logger LOG = LoggerFactory.getLogger(getClass());
LOG.error("Fail to [EXECUTE], {}.", StackTraceUtil.stackTrace(e));
if (nodeExecutor != null) {
nodeExecutor.execute(new Status(RaftError.EIO, "Fail to [EXECUTE]"), isLeader);
}
setCriticalError(closure, "Fail to [EXECUTE]", e);
} finally {
timeCtx.stop();
}
}
@Before
public void setUp() throws Exception {
super.setUp();
placeId = UUID.randomUUID();
address = Address.platformService(UUID.randomUUID(), RuleCapability.NAMESPACE, 1);
context =
PlatformRuleContext
.builder()
.withLogger(LoggerFactory.getLogger(TestPlatformRuleContext.class))
.withModels(new RuleModelStore())
.withPlatformBus(platformBus)
.withEventLoop(eventLoop)
.withPlaceId(placeId)
.withSource(address)
.withTimeZone(TimeZone.getDefault())
.build();
}
@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);
}
}
public boolean schedule(Class scheduleClazz, Callable<Boolean> callable) {
Logger logger = LoggerFactory.getLogger(scheduleClazz);
String loggingName = scheduleClazz.getSimpleName();
boolean flag = false;
long startTime = System.currentTimeMillis();
String taskId = loggingName + "_" + startTime;
logger.info("Executing {}, At: {}, id: {}", loggingName, new Date(), taskId);
try {
flag = callable.call();
}catch (Exception e) {
logger.info("Exception Occured: {}" ,ExceptionUtil.getMessage(e));
}
long endTime = System.currentTimeMillis();
String result = flag == true?"OK," : "FAILED,";
logger.info("Executing {}, {}, Cost: {}ms id: {}",
loggingName, result,
(endTime - startTime),
taskId);
return flag;
}
/**
* Verifies that this is indeed a new container.
*
* @param containerFile - Container File to verify
* @throws FileAlreadyExistsException
*/
public static void verifyIsNewContainer(File containerFile) throws
FileAlreadyExistsException {
Logger log = LoggerFactory.getLogger(ContainerSet.class);
Preconditions.checkNotNull(containerFile, "containerFile Should not be " +
"null");
if (containerFile.getParentFile().exists()) {
log.error("Container already exists on disk. File: {}", containerFile
.toPath());
throw new FileAlreadyExistsException("container already exists on " +
"disk.");
}
}
public void resetLogToOriginal() throws Exception {
final LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
context.reset();
final JoranConfigurator configurator = new JoranConfigurator();
configurator.setContext(context);
configurator.doConfigure(this.getClass().getClassLoader().getResource("logback-test.xml"));
}
@Override
@PostConstruct
protected void initialize(){
RequestMethod requestMethod = RequestMethod.GET;
setFieldsByProperties(siteProperties, requestMethod, generateHeader(),generateRequestBody());
injectBeansByContext(context);
setLog(LoggerFactory.getLogger(getClass()));
}
private void initialize(RuleEnvironment environment, DefaultPlaceExecutor executor) {
TimeZone tz = getTimeZone(environment.getPlaceId(), executor.getModelStore());
// TODO make this pluggable
List<PlaceEventHandler> handlers = new ArrayList<>();
{
RuleCatalog catalog = ruleCatalogLoader.getCatalogForPlace(environment.getPlaceId());
PlatformRuleContext.Builder builder =
PlatformRuleContext
.builder()
.withEventLoop(eventLoop)
.withPlatformBus(platformBus)
.withPlaceId(environment.getPlaceId())
.withModels(executor.getModelStore())
.withTimeZone(tz)
;
for(RuleDefinition definition: environment.getRules()) {
Address address = Address.platformService(definition.getId().getRepresentation(), RuleCapability.NAMESPACE);
builder.withSource(address);
builder.withVariables(definition.getVariables());
builder.withLogger(LoggerFactory.getLogger("rules." + definition.getRuleTemplate()));
Rule rule = instantiate(catalog, definition, builder.build(), environment, address);
if(rule == null) {
definition.setDisabled(true);
}
else {
RuleTemplate template = catalog.getById(definition.getRuleTemplate());
boolean premium = template != null && template.isPremium();
handlers.add(new RuleHandler(rule, definition, ruleDefDao, premium));
}
}
}
List<SceneHandler> sceneHandlers = sceneHandlerFactory.create(environment, executor.getModelStore());
handlers.addAll(sceneHandlers);
executor.setHandlers(handlers);
}
@Override
public void setLoggerLevel(String name, String level) {
LoggerContext loggerContext = (LoggerContext)LoggerFactory.getILoggerFactory();
List<Logger> loggerList = loggerContext.getLoggerList();
for (ch.qos.logback.classic.Logger logger : loggerList) {
if (name.equals(logger.getName())) {
logger.setLevel(Level.valueOf(level));
}
}
}
public TestConfig(String configPath) {
super(configPath);
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
JoranConfigurator configurator = new JoranConfigurator();
configurator.setContext(lc);
lc.reset();
try {
configurator.doConfigure(getLogBackXmlPath());
} catch (JoranException e) {
e.printStackTrace();
}
}
private RuleContext createSimpleRuleContext(UUID placeId) {
PlaceEnvironmentExecutor executor = registry.getExecutor(placeId).orNull();
Collection<Model> models = executor != null ?
executor.getModelStore().getModels() :
modelDao.loadModelsByPlace(placeId, RuleModelStore.TRACKED_TYPES);
// use a simple context just for resolving
SimpleContext context = new SimpleContext(placeId, Address.platformService("rule"), LoggerFactory.getLogger("rules." + placeId));
models.stream().filter((m) -> m != null).forEach((m) -> context.putModel(m));
return context;
}
@Override
@PostConstruct
protected void initialize(){
RequestMethod requestMethod = RequestMethod.GET;
setFieldsByProperties(siteProperties, requestMethod, generateHeader(),generateRequestBody());
injectBeansByContext(context);
setLog(LoggerFactory.getLogger(getClass()));
this.elementClass = ITEM_KEY;
}
@PutMapping("/logs")
@ResponseStatus(HttpStatus.NO_CONTENT)
@Timed
public void changeLevel(@RequestBody LoggerVM jsonLogger) {
LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
context.getLogger(jsonLogger.getName()).setLevel(Level.valueOf(jsonLogger.getLevel()));
}
@Before
public void setUp() {
delegate = new SimpleContext(UUID.randomUUID(), Address.platformService(UUID.randomUUID(), "rule"), LoggerFactory.getLogger(TestThresholdTrigger.class));
delegate.setVariable("_baseVar", "basevalue");
delegate.clearDirty();
context1 = new NamespaceContext("context1", delegate);
context2 = new NamespaceContext("context2", delegate);
}
private void hijackStdio() {
Logger stdoutLogger = LoggerFactory.getLogger("stdout");
Logger stderrLogger = LoggerFactory.getLogger("stderr");
PrintStream newOut = new PrintStream(new StdioOutputStream(stdoutLogger));
PrintStream newErr = new PrintStream(new StdioOutputStream(stderrLogger));
System.setOut(newOut);
System.setErr(newErr);
}
public ClosureShardingAlgorithm(final String expression, final String logRoot) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(expression));
Preconditions.checkArgument(!Strings.isNullOrEmpty(logRoot));
Binding binding = new Binding();
binding.setVariable("log", LoggerFactory.getLogger(Joiner.on(".").join("com.dangdang.ddframe.rdb.sharding.configFile", logRoot.trim())));
closureTemplate = (Closure) new GroovyShell(binding).evaluate(Joiner.on("").join("{it -> \"", expression.trim(), "\"}"));
}
private static Logger buildInfoByLevel(String name, Level logLevel, String fileName) {
RollingFileAppender appender = new AppenderBuild().getAppender(name, logLevel, fileName);
LoggerContext context = (LoggerContext)LoggerFactory.getILoggerFactory();
Logger logger = context.getLogger(name);
logger.setAdditive(false);
logger.addAppender(appender);
return logger;
}