Show registered workflows and Activities

sdk-workflows/src/main/java/io/dapr/workflows/runtime/WorkflowRuntimeBuilder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 The Dapr Authors
+ * Copyright 2024 The Dapr Authors
  * 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
@@ -18,11 +18,11 @@
 import io.dapr.workflows.Workflow;
 import io.dapr.workflows.internal.ApiTokenClientInterceptor;
 import io.grpc.ClientInterceptor;
-
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 public class WorkflowRuntimeBuilder {
   private static volatile WorkflowRuntime instance;
@@ -31,14 +31,20 @@ public class WorkflowRuntimeBuilder {
   private Set<String> workflows = new HashSet<String>();
   private Set<String> activities = new HashSet<String>();
   private static ClientInterceptor WORKFLOW_INTERCEPTOR = new ApiTokenClientInterceptor();
+  private final Set<String> activitySet = Collections.synchronizedSet(new HashSet<>());
+  private final Set<String> workflowSet = Collections.synchronizedSet(new HashSet<>());
 
   /**
    * Constructs the WorkflowRuntimeBuilder.
    */
   public WorkflowRuntimeBuilder() {
+    this(LoggerFactory.getLogger(WorkflowRuntimeBuilder.class));
+  }
+
+  WorkflowRuntimeBuilder(Logger logger) {
     this.builder = new DurableTaskGrpcWorkerBuilder().grpcChannel(
-                          NetworkUtils.buildGrpcManagedChannel(WORKFLOW_INTERCEPTOR));
-    this.logger = Logger.getLogger(WorkflowRuntimeBuilder.class.getName());
+        NetworkUtils.buildGrpcManagedChannel(WORKFLOW_INTERCEPTOR));
+    this.logger = logger;
   }
 
   /**
@@ -54,7 +60,9 @@ public WorkflowRuntime build() {
         }
       }
     }
-    this.logger.log(Level.INFO, "Successfully built dapr workflow runtime");
+    this.logger.info("List of registered workflows: " + this.workflowSet);
+    this.logger.info("List of registered activites: " + this.activitySet);
+    this.logger.info("Successfully built dapr workflow runtime");
     return instance;
   }
 
@@ -69,7 +77,8 @@ public <T extends Workflow> WorkflowRuntimeBuilder registerWorkflow(Class<T> cla
     this.builder = this.builder.addOrchestration(
         new OrchestratorWrapper<>(clazz)
     );
-    this.logger.log(Level.INFO, "Registered Workflow: " +  clazz.getSimpleName());
+    this.workflowSet.add(clazz.getCanonicalName());
+    this.logger.info("Registered Workflow: " +  clazz.getSimpleName());
     this.workflows.add(clazz.getSimpleName());
     return this;
   }
@@ -84,7 +93,8 @@ public <T extends WorkflowActivity> void registerActivity(Class<T> clazz) {
     this.builder = this.builder.addActivity(
         new ActivityWrapper<>(clazz)
     );
-    this.logger.log(Level.INFO, "Registered Activity: " +  clazz.getSimpleName());
+    this.activitySet.add(clazz.getCanonicalName());
+    this.logger.info("Registered Activity: " +  clazz.getSimpleName());
     this.activities.add(clazz.getSimpleName());
   }
 

sdk-workflows/src/test/java/io/dapr/workflows/runtime/WorkflowRuntimeBuilderTest.java

@@ -1,18 +1,28 @@
+/*
+ * Copyright 2024 The Dapr Authors
+ * 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 io.dapr.workflows.runtime;
 
 
 import io.dapr.workflows.Workflow;
 import io.dapr.workflows.WorkflowStub;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.slf4j.Logger;
 
-import static org.junit.Assert.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
-import java.util.logging.Logger;
-import java.util.logging.Handler;
-import java.util.logging.LogRecord;
 
 public class WorkflowRuntimeBuilderTest {
   public static class TestWorkflow extends Workflow {
@@ -51,36 +61,19 @@ public void loggingOutputTest() {
     ByteArrayOutputStream outStreamCapture = new ByteArrayOutputStream();
     System.setOut(new PrintStream(outStreamCapture));
 
-    LogCaptureHandler testLoggerHandler = new LogCaptureHandler();
-    Logger testLogger = Logger.getLogger(WorkflowRuntimeBuilder.class.getName());
+    Logger testLogger = Mockito.mock(Logger.class);
 
-    testLogger.addHandler(testLoggerHandler);
-
-    // indexOf will return -1 if the string is not found.
-    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerWorkflow(TestWorkflow.class));
-    assertNotEquals(-1, testLoggerHandler.capturedLog.indexOf("Registered Workflow: TestWorkflow"));
-    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerActivity(TestActivity.class));
-    assertNotEquals(-1, testLoggerHandler.capturedLog.indexOf("Registered Activity: TestActivity"));
+    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder(testLogger).registerWorkflow(TestWorkflow.class));
+    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder(testLogger).registerActivity(TestActivity.class));
 
     WorkflowRuntimeBuilder wfRuntime = new WorkflowRuntimeBuilder();
 
     wfRuntime.build();
-  }
-
-  private static class LogCaptureHandler extends Handler {
-    private StringBuilder capturedLog = new StringBuilder();
-
-    @Override
-    public void publish(LogRecord record) {
-      capturedLog.append(record.getMessage()).append(System.lineSeparator());
-    }
-
-    @Override
-    public void flush(){
-    }
 
-    @Override
-    public void close() throws SecurityException {
-    }
+    Mockito.verify(testLogger, Mockito.times(1))
+        .info(Mockito.eq("Registered Workflow: TestWorkflow"));
+    Mockito.verify(testLogger, Mockito.times(1))
+        .info(Mockito.eq("Registered Activity: TestActivity"));
   }
+
 }