Java util log handler implementation.

Author: mjfryc

README.md

@@ -19,11 +19,17 @@ Unit tests
 
 Tiny [Grafana Loki](https://grafana.com/oss/loki/) client (log sender) written in pure Java 1.8 without any external
 dependencies. One of Grafana Loki third-party clients mentioned
-in [documentation](https://grafana.com/docs/loki/v3.4.x/send-data/).
+in [documentation](https://grafana.com/docs/loki/v3.4.x/send-data/). It is customizable and easy to integrate
+but is not optimized for performance.
+See other reliable clients mentioned in documentation.
 
 * Implements JSON variant of [Loki API](https://grafana.com/docs/loki/latest/api/#post-lokiapiv1push)
 * Works with **Android** and **Java SE**
 * Thread safe
+* May added to [java.util.logging](https://docs.oracle.com/javase/8/docs/api/java/util/logging/package-summary.html)
+  as a log [Handler](https://docs.oracle.com/javase/8/docs/api/java/util/logging/Handler.html)
+  (and then may be called from [SLF4J](https://www.slf4j.org/)
+  using [slf4j-jdk14 provider](https://www.slf4j.org/manual.html)).
 
 ## Examples
 
@@ -139,6 +145,35 @@ public class Sample {
 }
 ```
 
+### SLF4J with java.util.logging example
+
+```groovy
+dependencies {
+    implementation("org.slf4j:slf4j-jdk14:2.0.17")
+    implementation("org.slf4j:slf4j-api:2.0.17")
+    implementation("io.github.mjfryc:mjaron-tinyloki-java:1.1.6")
+}
+```
+
+```java
+import pl.mjaron.tinyloki.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Sample {
+    public static void main(String[] args) {
+
+        TinyLokiJulHandler.install(TinyLoki
+                .withUrl("http://localhost:3100")
+                .withBasicAuth("user", "pass")
+                .withLabels(Labels.of(Labels.SERVICE_NAME, "integration_test")));
+
+        Logger logger = LoggerFactory.getLogger("julIntegrationTest");
+        logger.info("Hello info.");
+    }
+}
+```
+
 ## Integration
 
 ### Maven Central
@@ -214,7 +249,8 @@ If this size is exceeded, the server may respond with HTTP error `500`, e.g:
 rpc error: code = ResourceExhausted desc = grpc: received message larger than max (6331143 vs. 4194304)
 ```
 
-By default (`BasicBuffering`) The TinyLoki tries to fill the data buffers and if the next log would exceed the size limit,
+By default (`BasicBuffering`) The TinyLoki tries to fill the data buffers and if the next log would exceed the size
+limit,
 new buffer is allocated instead. Custom buffer size may be configured with:
 
 ```java
@@ -299,15 +335,14 @@ classDiagram
 
     VerboseLogMonitor --|> ILogMonitor: implements
     ErrorLogMonitor --|> ILogMonitor: implements
-
     ILogStream <.. ILogCollector: create
     ILogCollector --* TinyLoki
-    Labels <.. ILogCollector : use
+    Labels <.. ILogCollector: use
     ILogSender --* TinyLoki
     GzipLogEncoder --|> ILogEncoder: implements
     ILogEncoder --* TinyLoki
     ILogMonitor --* TinyLoki
-    JsonLogStream --|>  ILogStream: implements
+    JsonLogStream --|> ILogStream: implements
     JsonLogCollector --|> ILogCollector: implements
     JsonLogStream <.. JsonLogCollector: create
     HttpLogSender --|> ILogSender: implements

build.gradle

@@ -6,7 +6,7 @@ plugins {
 }
 
 group 'io.github.mjfryc'
-version '1.1.5'
+version '1.1.6'
 
 repositories {
     mavenCentral()

src/main/java/pl/mjaron/tinyloki/TinyLokiJulHandler.java

@@ -0,0 +1,122 @@
+package pl.mjaron.tinyloki;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+/**
+ * The log appender which writes logs from the {@link java.util.logging.Logger java.util.logging} library.
+ * It may be initialized with one of the {@link #install(Settings)} static methods.
+ *
+ * @since 1.1.6
+ */
+public class TinyLokiJulHandler extends java.util.logging.Handler {
+
+    /**
+     * Attaches the logger to root logger.
+     *
+     * @param settings The {@link TinyLoki} library {@link Settings}.
+     * @return Created {@link TinyLoki} instance.
+     */
+    public static TinyLoki install(Settings settings) {
+        java.util.logging.Logger rootLogger = java.util.logging.LogManager.getLogManager().getLogger("");
+        TinyLokiJulHandler handler = new TinyLokiJulHandler(settings);
+        rootLogger.addHandler(handler);
+        return handler.getLoki();
+    }
+
+    public static void install(String url) {
+        install(TinyLoki.withUrl(url));
+    }
+
+    public static void install(String url, String user, String pass) {
+        install(TinyLoki.withUrl(url).withBasicAuth(user, pass));
+    }
+
+    private static class StreamKey {
+        final String tag;
+        final Level level;
+        final int hash;
+
+        private StreamKey(String tag, Level level) {
+            this.tag = tag;
+            this.level = level;
+            this.hash = Objects.hash(tag, level);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            StreamKey that = (StreamKey) o;
+            return tag.equals(that.tag) && level == that.level;
+        }
+
+        @Override
+        public int hashCode() {
+            return this.hash;
+        }
+    }
+
+    private static String toTinyLokiLogLevel(final Level level) {
+        final int value = level.intValue();
+        if (value >= 1000) {        // SEVERE
+            return Labels.FATAL;
+        } else if (value >= 900) {  // WARNING
+            return Labels.WARN;
+        } else if (value >= 800) {  // INFO
+            return Labels.INFO;
+        } else if (value >= 700) {  // CONFIG
+            return Labels.DEBUG;
+        } else {
+            return Labels.VERBOSE;
+        }
+    }
+
+    private final TinyLoki loki;
+    private Map<StreamKey, ILogStream> streams = new HashMap<>();
+
+    public TinyLokiJulHandler(TinyLoki loki) {
+        this.loki = loki;
+    }
+
+    public TinyLokiJulHandler(Settings settings) {
+        loki = TinyLoki.open(settings);
+    }
+
+    public TinyLoki getLoki() {
+        return loki;
+    }
+
+    @Override
+    synchronized public void publish(LogRecord logRecord) {
+        StreamKey key = new StreamKey(logRecord.getLoggerName(), logRecord.getLevel());
+        ILogStream stream = streams.get(key);
+        if (stream == null) {
+            Labels streamLabels = Labels.of().l("tag", logRecord.getLoggerName()).l(Labels.LEVEL, toTinyLokiLogLevel(logRecord.getLevel()));
+            stream = loki.openStream(streamLabels);
+            streams.put(key, stream);
+        }
+        stream.log(logRecord.getMessage());
+    }
+
+    @Override
+    public void flush() {
+        try {
+            loki.sync();
+        } catch (InterruptedException ignored) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    @Override
+    public void close() throws SecurityException {
+        try {
+            loki.closeSync();
+        } catch (InterruptedException ignored) {
+            Thread.currentThread().interrupt();
+        }
+    }
+}

src/test/java/pl/mjaron/tinyloki/JulIntegrationTest.java

@@ -0,0 +1,36 @@
+package pl.mjaron.tinyloki;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
+
+import java.util.logging.Logger;
+
+/**
+ * To enable this test, modify the run configuration by adding environment variable:
+ * <pre>{@code
+ * TINYLOKI_INTEGRATION=1
+ * }</pre>
+ * <p>
+ * Integration test server must be enabled to receive logs, see <code>integration-test-server</code> project directory.
+ */
+@EnabledIfEnvironmentVariable(named = "TINYLOKI_INTEGRATION", matches = "1")
+public class JulIntegrationTest {
+// @formatter:off
+
+    @Test
+    void julIntegrationTest()throws InterruptedException {
+        // Optionally the TinyLoki instance may be gained.
+        // TinyLoki loki =
+
+        TinyLokiJulHandler.install(TinyLoki.withUrl("http://localhost:3100")
+                .withBasicAuth("user", "pass")
+                .withLabels(Labels.of(Labels.SERVICE_NAME, "integration_test")));
+        Logger logger = Logger.getLogger("julIntegrationTest");
+        logger.info("Hello info.");
+
+        // Optionally, additional logs synchronization may be performed.
+        // loki.sync();
+    }
+
+// @formatter:on
+}

src/test/java/pl/mjaron/tinyloki/TinyLokiJulHandlerTest.java

@@ -0,0 +1,24 @@
+package pl.mjaron.tinyloki;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TinyLokiJulHandlerTest {
+
+    @Test
+    void basicTest() {
+        MemoryLogSender memoryLogSender = new MemoryLogSender();
+
+        // @formatter:off
+        TinyLokiJulHandler.install(TinyLoki.withUrl("dummy_url")
+                .withLogSender(memoryLogSender)
+                .withExecutor(new SyncExecutor())
+                .withVerboseLogMonitor(true));
+        // @formatter:on
+        java.util.logging.Logger logger = java.util.logging.Logger.getLogger("julBasicTest");
+        logger.info("Hello world.");
+        String data = memoryLogSender.getAsString();
+        assertTrue(data.contains("Hello world."));
+    }
+}