Add setter for log prefix in ObjectLogger and StreamLogger.

metafacture-monitoring/build.gradle

@@ -22,5 +22,5 @@ dependencies {
   implementation project(':metafacture-commons')
   testImplementation "junit:junit:${versions.junit}"
   testImplementation "org.mockito:mockito-core:${versions.mockito}"
-  testRuntimeOnly slf4j_provider
+  testImplementation "org.simplify4u:slf4j2-mock:${versions.slf4j_mock}"
 }

metafacture-monitoring/src/main/java/org/metafacture/monitoring/ObjectLogger.java

@@ -41,25 +41,36 @@ public final class ObjectLogger<T>
 
     private static final MetafactureLogger LOG = new MetafactureLogger(ObjectLogger.class);
 
-    private final String logPrefix;
+    private String logPrefix = "";
 
     /**
      * Creates an instance of {@link ObjectLogger}.
      */
     public ObjectLogger() {
-        this("");
     }
 
     /**
      * Creates an instance of {@link ObjectLogger} by a given prefix of the log
      * messages.
      *
+     * @deprecated Use {@link #setPrefix} instead.
+     *
      * @param logPrefix the prefix of the log messages
      */
+    @Deprecated/*(since="9.0", forRemoval=true)*/
     public ObjectLogger(final String logPrefix) {
         this.logPrefix = logPrefix;
     }
 
+    /**
+     * Sets the prefix used when logging messages.
+     *
+     * @param prefix the prefix of the log messages
+     */
+    public void setPrefix(final String prefix) {
+        this.logPrefix = prefix;
+    }
+
     @Override
     public void process(final T obj) {
         LOG.externalDebug("{}{}", logPrefix, obj);

metafacture-monitoring/src/main/java/org/metafacture/monitoring/StreamLogger.java

@@ -41,23 +41,34 @@ public final class StreamLogger
 
     private static final MetafactureLogger LOG = new MetafactureLogger(StreamLogger.class);
 
-    private final String logPrefix;
+    private String logPrefix = "";
 
     /**
      * Creates an instance of {@link StreamLogger}.
      */
     public StreamLogger() {
-        this("");
     }
 
     /**
      * Creates an instance of {@link StreamLogger} by a given prefix used when log
      * messages.
      *
+     * @deprecated Use {@link #setPrefix} instead.
+     *
      * @param logPrefix the prefix of the log messages
      */
+    @Deprecated/*(since="9.0", forRemoval=true)*/
     public StreamLogger(final String logPrefix) {
-        this.logPrefix = logPrefix;
+        setPrefix(logPrefix);
+    }
+
+    /**
+     * Sets the prefix used when logging messages.
+     *
+     * @param prefix the prefix of the log messages
+     */
+    public void setPrefix(final String prefix) {
+        this.logPrefix = prefix;
     }
 
     @Override

metafacture-monitoring/src/test/java/org/metafacture/monitoring/ObjectLoggerTest.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2026 hbz NRW
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.metafacture.monitoring;
+
+import org.metafacture.framework.ObjectReceiver;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.slf4j.Logger;
+
+/**
+ * Tests for class {@link ObjectLogger}.
+ *
+ * @author Jens Wille
+ *
+ */
+@RunWith(MockitoJUnitRunner.class)
+public final class ObjectLoggerTest extends TestHelpers {
+
+    @Mock(name = "external.org.metafacture.monitoring.ObjectLogger")
+    private Logger logLogger;
+
+    @Mock
+    private ObjectReceiver<String> receiver;
+
+    private ObjectLogger<String> logger;
+
+    public ObjectLoggerTest() {
+    }
+
+    @Before
+    public void setup() {
+        logger = new ObjectLogger<>();
+        logger.setReceiver(receiver);
+    }
+
+    @Test
+    public void shouldForwardAllProcessedObjects() {
+        logger.process("object");
+        logger.resetStream();
+        logger.closeStream();
+
+        final InOrder ordered = Mockito.inOrder(receiver);
+        ordered.verify(receiver).process("object");
+        ordered.verify(receiver).resetStream();
+        ordered.verify(receiver).closeStream();
+        ordered.verifyNoMoreInteractions();
+        Mockito.verifyNoMoreInteractions(receiver);
+
+        assertLog(logLogger, "DEBUG", c -> {
+            assertLog(c, "{}{}", "", "object");
+            assertLog(c, "{}resetStream", "");
+            assertLog(c, "{}closeStream", "");
+        });
+    }
+
+    @Test
+    public void shouldActAsSinkIfNoReceiverIsSet() {
+        logger.setReceiver(null);
+
+        logger.process("object");
+        logger.resetStream();
+        logger.closeStream();
+
+        Mockito.verifyNoMoreInteractions(receiver);
+
+        assertLog(logLogger, "DEBUG", c -> {
+            assertLog(c, "{}{}", "", "object");
+            assertLog(c, "{}resetStream", "");
+            assertLog(c, "{}closeStream", "");
+        });
+    }
+
+    @Test
+    public void shouldLogWithPrefix() {
+        final String prefix = "prefix:";
+        logger.setPrefix(prefix);
+
+        logger.process("object");
+        logger.resetStream();
+        logger.closeStream();
+
+        assertLog(logLogger, "DEBUG", c -> {
+            assertLog(c, "{}{}", prefix, "object");
+            assertLog(c, "{}resetStream", prefix);
+            assertLog(c, "{}closeStream", prefix);
+        });
+    }
+
+}

metafacture-monitoring/src/test/java/org/metafacture/monitoring/ObjectTimerTest.java

@@ -20,14 +20,22 @@
 
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.slf4j.Logger;
 
 /**
  * Tests for class {@link ObjectTimer}.
  *
  * @author Christoph Böhme
  *
  */
-public final class ObjectTimerTest {
+@RunWith(MockitoJUnitRunner.class)
+public final class ObjectTimerTest extends TestHelpers {
+
+    @Mock(name = "external.org.metafacture.monitoring.TimerBase")
+    private Logger logger;
 
     private ObjectTimer<String> objectTimer;
     private BenchmarkedModule benchmarkedModule;
@@ -44,18 +52,34 @@ public void setup() {
 
     @Test
     public void testShouldMeasureExecutionTime() {
-
         objectTimer.process("");
         objectTimer.process("");
         objectTimer.process("");
         objectTimer.process("");
         objectTimer.closeStream();
+
+        assertLog(logger, "", 4);
     }
 
     @Test
     public void testShouldHandleImmediateCloseStreamWithNoProcessing() {
+        objectTimer.closeStream();
+        assertLog(logger, "", 0);
+    }
 
+    @Test
+    public void shouldLogWithPrefix() {
+        final String prefix = "prefix:";
+        objectTimer = new ObjectTimer<>(prefix);
+        objectTimer.setReceiver(benchmarkedModule);
+
+        objectTimer.process("");
+        objectTimer.process("");
+        objectTimer.process("");
+        objectTimer.process("");
         objectTimer.closeStream();
+
+        assertLog(logger, prefix, 4);
     }
 
     /**

metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamLoggerTest.java

@@ -20,10 +20,12 @@
 
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.slf4j.Logger;
 
 /**
  * Tests for class {@link StreamLogger}.
@@ -32,7 +34,11 @@
  * @author Christoph Böhme (refactored to Mockito)
  *
  */
-public final class StreamLoggerTest {
+@RunWith(MockitoJUnitRunner.class)
+public final class StreamLoggerTest extends TestHelpers {
+
+    @Mock(name = "external.org.metafacture.monitoring.StreamLogger")
+    private Logger logLogger;
 
     @Mock
     private StreamReceiver receiver;
@@ -44,7 +50,6 @@ public StreamLoggerTest() {
 
     @Before
     public void setup() {
-        MockitoAnnotations.initMocks(this);
         logger = new StreamLogger();
         logger.setReceiver(receiver);
     }
@@ -67,6 +72,18 @@ public void shouldForwardAllReceivedEvents() {
         ordered.verify(receiver).endRecord();
         ordered.verify(receiver).resetStream();
         ordered.verify(receiver).closeStream();
+        ordered.verifyNoMoreInteractions();
+        Mockito.verifyNoMoreInteractions(receiver);
+
+        assertLog(logLogger, "DEBUG", c -> {
+            assertLog(c, "{}start record {}", "", "1");
+            assertLog(c, "{}start entity {}", "", "entity");
+            assertLog(c, "{}literal {}={}", "", "literal", "value");
+            assertLog(c, "{}end entity", "");
+            assertLog(c, "{}end record", "");
+            assertLog(c, "{}resetStream", "");
+            assertLog(c, "{}closeStream", "");
+        });
     }
 
     @Test
@@ -81,7 +98,41 @@ public void shouldActAsSinkIfNoReceiverIsSet() {
         logger.resetStream();
         logger.closeStream();
 
-        // No exceptions expected
+        Mockito.verifyNoMoreInteractions(receiver);
+
+        assertLog(logLogger, "DEBUG", c -> {
+            assertLog(c, "{}start record {}", "", "1");
+            assertLog(c, "{}start entity {}", "", "entity");
+            assertLog(c, "{}literal {}={}", "", "literal", "value");
+            assertLog(c, "{}end entity", "");
+            assertLog(c, "{}end record", "");
+            assertLog(c, "{}resetStream", "");
+            assertLog(c, "{}closeStream", "");
+        });
+    }
+
+    @Test
+    public void shouldLogWithPrefix() {
+        final String prefix = "prefix:";
+        logger.setPrefix(prefix);
+
+        logger.startRecord("1");
+        logger.startEntity("entity");
+        logger.literal("literal", "value");
+        logger.endEntity();
+        logger.endRecord();
+        logger.resetStream();
+        logger.closeStream();
+
+        assertLog(logLogger, "DEBUG", c -> {
+            assertLog(c, "{}start record {}", prefix, "1");
+            assertLog(c, "{}start entity {}", prefix, "entity");
+            assertLog(c, "{}literal {}={}", prefix, "literal", "value");
+            assertLog(c, "{}end entity", prefix);
+            assertLog(c, "{}end record", prefix);
+            assertLog(c, "{}resetStream", prefix);
+            assertLog(c, "{}closeStream", prefix);
+        });
     }
 
 }