io.vertx.core.logging.Logger Java Examples

public ConditionalLogger(String key, Logger logger) {
    this.key = key; // can be null
    this.logger = Objects.requireNonNull(logger);

    messageToCount = Caffeine.newBuilder()
            .maximumSize(CACHE_MAXIMUM_SIZE)
            .expireAfterWrite(EXPIRE_CACHE_DURATION, TimeUnit.HOURS)
            .<String, AtomicInteger>build()
            .asMap();

    messageToWait = Caffeine.newBuilder()
            .maximumSize(CACHE_MAXIMUM_SIZE)
            .expireAfterWrite(EXPIRE_CACHE_DURATION, TimeUnit.HOURS)
            .<String, Long>build()
            .asMap();
}
 

public static void main(String[] args) {
    // Use logback for logging
    File logbackFile = new File("config", "logback.xml");
    System.setProperty("logback.configurationFile", logbackFile.getAbsolutePath());
    System.setProperty(LoggerFactory.LOGGER_DELEGATE_FACTORY_CLASS_NAME, SLF4JLogDelegateFactory.class.getName());
    Logger log = LoggerFactory.getLogger(Runner.class);

    // Setup the http server
    log.info("Starting server for: http://localhost:8080/hello");
    Vertx vertx = Vertx.vertx();
    Router router = Router.router(vertx);

    router.route("/hello").handler(rc -> {
        log.info("Got hello request");
        rc.response().end("World");
    });

    vertx.createHttpServer()
            .requestHandler(router::accept)
            .listen(8080);

}
 

@Override
public void handle(RoutingContext context) {
    final HttpServerRequest request = context.request();

    final BiConsumer<Logger, String> loggingLevelModifier;
    final int records;

    final String loggingLevel = request.getParam(LOGGING_PARAM);
    final String recordsAsString = request.getParam(RECORDS_PARAM);

    try {
        loggingLevelModifier = loggingLevel(loggingLevel);
        records = records(recordsAsString);
    } catch (IllegalArgumentException e) {
        context.response()
                .setStatusCode(HttpResponseStatus.BAD_REQUEST.code())
                .end(e.getMessage());
        return;
    }

    adminManager.setupByCounter(AdminManager.COUNTER_KEY, records, loggingLevelModifier, onFinish());

    context.response()
            .end(String.format("Logging level was changed to %s, for %s requests", loggingLevel, recordsAsString));
}
 

private static BiConsumer<Logger, String> loggingLevel(String level) {
    if (StringUtils.isEmpty(level)) {
        throw new IllegalArgumentException("Logging level cannot be empty");
    }
    switch (level) {
        case "info":
            return Logger::info;
        case "warn":
            return Logger::warn;
        case "trace":
            return Logger::trace;
        case "error":
            return Logger::error;
        case "fatal":
            return Logger::fatal;
        case "debug":
            return Logger::debug;
        default:
            throw new IllegalArgumentException(String.format("Invalid logging level: %s", level));
    }
}
 

@Test
public void shouldExecuteByTime() throws InterruptedException {
    // given
    adminManager.setupByTime(KEY, 1000, (BiConsumer<Logger, String>) Logger::info,
            (BiConsumer<Logger, String>) (logger, text) -> logger.info(String.format("Done %s", text)));

    // when
    for (int i = 0; i < 15; i++) {
        adminManager.accept(KEY, logger, "Text");
        Thread.sleep(100);
    }

    // then
    verify(logger, times(10)).info("Text");
    verify(logger, times(5)).info("Done Text");
}
 

public AsyncFileReaderImpl(Context context, long startPosition, int bufferSize, long length, AsynchronousFileChannel dataFile, Logger log) {
    this.log = log;
    this.bufferSize = bufferSize;
    this.readPos = startPosition;
    this.bytesRemaining = length;
    this.startPosition = startPosition;
    this.ch = dataFile;
    this.context = context;
}
 

public AsyncFileWriterImpl(long startPosition, WriteQueueSupport<AsyncFileWriter> writeQueueSupport, Context context, AsynchronousFileChannel dataFile, Logger log) {
    this.log = log;
    this.startPosition = startPosition;
    this.writePos = startPosition;
    this.ch = dataFile;
    this.context = context;
    this.writeQueueSupport = writeQueueSupport;
    this.lastWriteTime = System.currentTimeMillis();
}
 

static <T> Handler<AsyncResult<T>> logIfFailed(final String msg, final Logger log) {
  return res -> {
    if (res.failed()) {
      if (msg != null) {
        log.error(msg, res.cause());
      } else {
        log.error(res.cause());
      }
    }
  };
}
 

@Test
public void shouldReturnFalseIfKeyIsMissing() {
    // given
    adminManager.setupByCounter(KEY, 20, (BiConsumer<Logger, String>) Logger::info,
            (BiConsumer<Logger, String>) (logger, text) -> logger.info(String.format("Done %s", text)));

    // when
    boolean contains = adminManager.contains("WrongKey");

    // then
    assertThat(contains).isFalse();
}
 

@Test
public void shouldReturnTrueIfAdminManagerContainsKey() {
    // given
    adminManager.setupByCounter(KEY, 20, (BiConsumer<Logger, String>) Logger::info,
            (BiConsumer<Logger, String>) (logger, text) -> logger.info(String.format("Done %s", text)));

    // when
    boolean contains = adminManager.contains(KEY);

    // then
    assertThat(contains).isTrue();
}
 

@Test
public void shouldExecuteFixedAmountOfTimes() {
    // given
    adminManager.setupByCounter(KEY, 20, (BiConsumer<Logger, String>) Logger::info,
            (BiConsumer<Logger, String>) (logger, text) -> logger.info(String.format("Done %s", text)));

    // when
    for (int i = 0; i < 30; i++) {
        adminManager.accept(KEY, logger, "Text");
    }

    // then
    verify(logger, times(20)).info("Text");
    verify(logger, times(10)).info("Done Text");
}
 

private static BiConsumer<Logger, String> defaultLogModifier(Logger defaultLogger) {
    if (defaultLogger.isTraceEnabled()) {
        return Logger::trace;
    } else if (defaultLogger.isDebugEnabled()) {
        return Logger::debug;
    } else if (defaultLogger.isInfoEnabled()) {
        return Logger::info;
    } else if (defaultLogger.isWarnEnabled()) {
        return Logger::warn;
    }
    return Logger::error;
}
 

/**
 * Calls {@link Consumer} if the given time for specified key is not exceeded.
 */
private void log(String key, long duration, TimeUnit unit, Consumer<Logger> consumer) {
    final long currentTime = Instant.now().toEpochMilli();
    final String resolvedKey = ObjectUtils.defaultIfNull(this.key, key);
    final long endTime = messageToWait.computeIfAbsent(resolvedKey, ignored -> calculateEndTime(duration, unit));

    if (currentTime >= endTime) {
        messageToWait.replace(resolvedKey, endTime, calculateEndTime(duration, unit));
        consumer.accept(logger);
    }
}
 

/**
 * Calls {@link Consumer} if the given limit for specified key is not exceeded.
 */
private void log(String key, int limit, Consumer<Logger> consumer) {
    final String resolvedKey = ObjectUtils.defaultIfNull(this.key, key);
    final AtomicInteger count = messageToCount.computeIfAbsent(resolvedKey, ignored -> new AtomicInteger());
    if (count.incrementAndGet() >= limit) {
        count.set(0);
        consumer.accept(logger);
    }
}
 

protected Logger getLogger() {
    return log;
}
 

public VertxApimanLogger(Logger logger) {
    this.logger = logger;
}
 

@Override
public Logger log() {
    return log;
}
 

public ConditionalLogger(Logger logger) {
    this(null, logger);
}
 

public VerticleHelper(Logger logger) {
    this.logger = logger;
}
 

public VerticleHelper(Logger logger) {
    this.logger = logger;
}
 

public VerticleHelper(Logger logger) {
    this.logger = logger;
}
 

public VerticleHelper(Logger logger) {
    this.logger = logger;
}
 

private BiConsumer<Logger, String> onFinish() {
    return (logger, message) -> defaultLogModifier(logger).accept(logger, message);
}
 

Logger log();