io.netty.util.internal.logging.InternalLogger Java Examples

/**
 * Try to cancel the {@link Promise} and log if {@code logger} is not {@code null} in case this fails.如果日志记录器不为空，则尝试取消承诺和日志，以防失败。
 */
public static void tryCancel(Promise<?> p, InternalLogger logger) {
    if (!p.cancel(false) && logger != null) {
        Throwable err = p.cause();
        if (err == null) {
            logger.warn("Failed to cancel promise because it has succeeded already: {}", p);
        } else {
            logger.warn(
                    "Failed to cancel promise because it has failed already: {}, unnotified cause:",
                    p, err);
        }
    }
}
 

@Override
public InternalLogger newInstance(String name) {
    InternalLogger baseLogger = ((Slf4JLoggerFactory) Slf4JLoggerFactory.INSTANCE).newInstance(name);
    if (name.equals(ResourceLeakDetector.class.getName())) {
        return new ResourceLeakAssertionLogger(baseLogger);
    } else {
        return baseLogger;
    }
}
 

private void executeVoid(@Nonnull Consumer<InternalLogger> consumer) {
  if (myDelegateLogger != null) {
    consumer.accept(myDelegateLogger);
    return;
  }

  Application application = ApplicationManager.getApplication();
  if (application != null) {
    myDelegateLogger = SLF4J_INSTANCE.newInstance(name());
    consumer.accept(myDelegateLogger);
  }
}
 

private boolean executeBool(@Nonnull Function<InternalLogger, Boolean> f) {
  if (myDelegateLogger != null) {
    return f.apply(myDelegateLogger);
  }

  Application application = ApplicationManager.getApplication();
  if (application != null) {
    myDelegateLogger = SLF4J_INSTANCE.newInstance(name());
    return f.apply(myDelegateLogger);
  }

  return false;
}
 

/**
 * Try to mark the {@link Promise} as failure and log if {@code logger} is not {@code null} in case this fails.尝试将承诺标记为失败，如果日志记录器在失败时不为空，则记录日志。
 */
public static void tryFailure(Promise<?> p, Throwable cause, InternalLogger logger) {
    if (!p.tryFailure(cause) && logger != null) {
        Throwable err = p.cause();
        if (err == null) {
            logger.warn("Failed to mark a promise as failure because it has succeeded already: {}", p, cause);
        } else {
            logger.warn(
                    "Failed to mark a promise as failure because it has failed already: {}, unnotified cause: {}",
                    p, ThrowableUtil.stackTraceToString(err), cause);
        }
    }
}
 

/**
 * Try to mark the {@link Promise} as success and log if {@code logger} is not {@code null} in case this fails.尝试将承诺标记为成功，如果日志记录器在失败时不为空，则记录日志。
 */
public static <V> void trySuccess(Promise<? super V> p, V result, InternalLogger logger) {
    if (!p.trySuccess(result) && logger != null) {
        Throwable err = p.cause();
        if (err == null) {
            logger.warn("Failed to mark a promise as success because it has succeeded already: {}", p);
        } else {
            logger.warn(
                    "Failed to mark a promise as success because it has failed already: {}, unnotified cause:",
                    p, err);
        }
    }
}
 

@SuppressWarnings("unchecked")
    private static void setChannelOption(
            Channel channel, ChannelOption<?> option, Object value, InternalLogger logger) {
        try {
//            设置渠道配置
            if (!channel.config().setOption((ChannelOption<Object>) option, value)) {
                logger.warn("Unknown channel option '{}' for channel '{}'", option, channel);
            }
        } catch (Throwable t) {
            logger.warn(
                    "Failed to set channel option '{}' with value '{}' for channel '{}'", option, value, channel, t);
        }
    }
 

@Override
public void operationComplete(ChannelFuture future) throws Exception {
    InternalLogger internalLogger = logNotifyFailure ? logger : null;
    if (future.isSuccess()) {
        Void result = future.get();
        PromiseNotificationUtil.trySuccess(delegate, result, internalLogger);
    } else if (future.isCancelled()) {
        PromiseNotificationUtil.tryCancel(delegate, internalLogger);
    } else {
        Throwable cause = future.cause();
        PromiseNotificationUtil.tryFailure(delegate, cause, internalLogger);
    }
}
 

@SuppressWarnings("unchecked")
private static void setChannelOption(
        Channel channel, ChannelOption<?> option, Object value, InternalLogger logger) {
    try {
        if (!channel.config().setOption((ChannelOption<Object>) option, value)) {
            logger.warn("Unknown channel option '{}' for channel '{}'", option, channel);
        }
    } catch (Throwable t) {
        logger.warn(
                "Failed to set channel option '{}' with value '{}' for channel '{}'", option, value, channel, t);
    }
}
 

@Override
public boolean isDebugEnabled() {
  return executeBool(InternalLogger::isDebugEnabled);
}
 

@Override
public boolean isInfoEnabled() {
  return executeBool(InternalLogger::isInfoEnabled);
}
 

public static InternalLogger getLogger(Class<?> c)
{
	return InternalLoggerFactory.getInstance(c);
}
 

@Override
public boolean isTraceEnabled() {
  return executeBool(InternalLogger::isTraceEnabled);
}
 

@Override
public boolean isWarnEnabled() {
  return executeBool(InternalLogger::isWarnEnabled);
}
 

@Override
public boolean isErrorEnabled() {
  return executeBool(InternalLogger::isErrorEnabled);
}
 

@Override
public InternalLogger newInstance(String name) {
    return new DubboLogger(LoggerFactory.getLogger(name));
}
 

@Override
protected InternalLogger newInstance(String name) {
    return new LtsLogger(name);
}
 

@Override
public InternalLogger newInstance(String name) {
    return new DubboLogger(LoggerFactory.getLogger(name));
}
 

@Override
protected InternalLogger newInstance(String name) {
  return new ApplicationInternalLogger(name);
}
 

@Override
public InternalLogger newInstance(String name) {
    return new DubboLogger(LoggerFactory.getLogger(name));
}
 

@Override
public InternalLogger newInstance(String name) {
    return new DubboLogger(LoggerFactory.getLogger(name));
}
 

TraceDnsQueryLifecycleObserver(DnsQuestion question, InternalLogger logger, InternalLogLevel level) {
    this.question = checkNotNull(question, "question");
    this.logger = checkNotNull(logger, "logger");
    this.level = checkNotNull(level, "level");
}
 

@Override
protected InternalLogger newInstance(String name) {
    return new JBossNettyInternalLogger(name);
}
 

@Override
protected InternalLogger getlogger() {

	return logger;
}
 

@Override
protected InternalLogger getlogger() {

	return logger;
}
 

static void setChannelOptions(
        Channel channel, Map.Entry<ChannelOption<?>, Object>[] options, InternalLogger logger) {
    for (Map.Entry<ChannelOption<?>, Object> e: options) {
        setChannelOption(channel, e.getKey(), e.getValue(), logger);
    }
}
 

static void setChannelOptions(
        Channel channel, Map<ChannelOption<?>, Object> options, InternalLogger logger) {
    for (Map.Entry<ChannelOption<?>, Object> e: options.entrySet()) {
        setChannelOption(channel, e.getKey(), e.getValue(), logger);
    }
}
 

private static void setChannelOptions(
        Channel channel, Map<ChannelOption<?>, Object> options, InternalLogger logger) {
    for (Map.Entry<ChannelOption<?>, Object> e: options.entrySet()) {
        setChannelOption(channel, e.getKey(), e.getValue(), logger);
    }
}
 

private Http2FrameLogger(InternalLogLevel level, InternalLogger logger) {
    this.level = checkNotNull(level, "level");
    this.logger = checkNotNull(logger, "logger");
}
 

TraceDnsQueryLifeCycleObserverFactory(InternalLogger logger, InternalLogLevel level) {
    this.logger = checkNotNull(logger, "logger");
    this.level = checkNotNull(level, "level");
}