diff --git a/java-sandbox/opentelemetry-v2/.gitignore b/java-sandbox/opentelemetry-v2/.gitignore new file mode 100644 index 0000000..b83d222 --- /dev/null +++ b/java-sandbox/opentelemetry-v2/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/java-sandbox/opentelemetry-v2/pom.xml b/java-sandbox/opentelemetry-v2/pom.xml new file mode 100644 index 0000000..88625ac --- /dev/null +++ b/java-sandbox/opentelemetry-v2/pom.xml @@ -0,0 +1,88 @@ + + 4.0.0 + + io.temporal.docs + opentelemetry-v2 + 1.0.0 + + + 21 + UTF-8 + + 1.41.0-SNAPSHOT + + + + + + io.opentelemetry + opentelemetry-bom + 1.66.0 + pom + import + + + + + + + io.temporal + temporal-sdk + ${temporal.version} + + + io.temporal + temporal-opentelemetry-v2 + ${temporal.version} + + + io.opentelemetry + opentelemetry-exporter-otlp + + + io.opentelemetry.instrumentation + opentelemetry-micrometer-1.5 + 2.32.0-alpha + + + io.opentelemetry.instrumentation + opentelemetry-logback-appender-1.0 + 2.32.0-alpha + + + ch.qos.logback + logback-classic + 1.5.6 + + + io.temporal + temporal-testing + ${temporal.version} + test + + + io.opentelemetry + opentelemetry-sdk-testing + test + + + org.junit.jupiter + junit-jupiter + 6.1.1 + test + + + + + + + maven-compiler-plugin + 3.13.0 + + + maven-surefire-plugin + 3.5.4 + + + + diff --git a/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingActivities.java b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingActivities.java new file mode 100644 index 0000000..6470ca1 --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingActivities.java @@ -0,0 +1,8 @@ +package io.temporal.docs.opentelemetryv2; + +import io.temporal.activity.ActivityInterface; + +@ActivityInterface +public interface GreetingActivities { + String composeGreeting(String name); +} diff --git a/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingActivitiesImpl.java b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingActivitiesImpl.java new file mode 100644 index 0000000..c5563ce --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingActivitiesImpl.java @@ -0,0 +1,26 @@ +package io.temporal.docs.opentelemetryv2; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Scope; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class GreetingActivitiesImpl implements GreetingActivities { + private static final Logger logger = LoggerFactory.getLogger(GreetingActivitiesImpl.class); + + @Override + public String composeGreeting(String name) { + logger.info("Formatting greeting for {}", name); + + Span span = + GlobalOpenTelemetry.getTracer(GreetingWorkflowImpl.INSTRUMENTATION_NAME) + .spanBuilder("format-greeting") + .startSpan(); + try (Scope ignored = span.makeCurrent()) { + return "Hello, " + name + "!"; + } finally { + span.end(); + } + } +} diff --git a/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingWorkflow.java b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingWorkflow.java new file mode 100644 index 0000000..1efdf0a --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingWorkflow.java @@ -0,0 +1,10 @@ +package io.temporal.docs.opentelemetryv2; + +import io.temporal.workflow.WorkflowInterface; +import io.temporal.workflow.WorkflowMethod; + +@WorkflowInterface +public interface GreetingWorkflow { + @WorkflowMethod + String greet(String name); +} diff --git a/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingWorkflowImpl.java b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingWorkflowImpl.java new file mode 100644 index 0000000..7317395 --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/GreetingWorkflowImpl.java @@ -0,0 +1,46 @@ +package io.temporal.docs.opentelemetryv2; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Scope; +import io.temporal.activity.ActivityOptions; +import io.temporal.workflow.Workflow; +import java.time.Duration; +import org.slf4j.Logger; + +public class GreetingWorkflowImpl implements GreetingWorkflow { + static final String INSTRUMENTATION_NAME = "io.temporal.docs.opentelemetryv2"; + + // @@@SNIPSTART java-opentelemetry-v2-workflow-logger + private static final Logger logger = Workflow.getLogger(GreetingWorkflowImpl.class); + // @@@SNIPEND + + private final GreetingActivities activities = + Workflow.newActivityStub( + GreetingActivities.class, + ActivityOptions.newBuilder().setStartToCloseTimeout(Duration.ofSeconds(10)).build()); + + @Override + public String greet(String name) { + // @@@SNIPSTART java-opentelemetry-v2-workflow-counter + GlobalOpenTelemetry.getMeter(INSTRUMENTATION_NAME) + .counterBuilder("greeting.workflow.runs") + .build() + .add(1); + // @@@SNIPEND + + logger.info("Requesting greeting for {}", name); + + // @@@SNIPSTART java-opentelemetry-v2-workflow-span + Span span = + GlobalOpenTelemetry.getTracer(INSTRUMENTATION_NAME) + .spanBuilder("request-greeting") + .startSpan(); + try (Scope ignored = span.makeCurrent()) { + return activities.composeGreeting(name); + } finally { + span.end(); + } + // @@@SNIPEND + } +} diff --git a/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/OpenTelemetrySetupExamples.java b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/OpenTelemetrySetupExamples.java new file mode 100644 index 0000000..2148baa --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/main/java/io/temporal/docs/opentelemetryv2/OpenTelemetrySetupExamples.java @@ -0,0 +1,100 @@ +package io.temporal.docs.opentelemetryv2; + +import com.uber.m3.tally.RootScopeBuilder; +import com.uber.m3.tally.Scope; +import io.micrometer.core.instrument.MeterRegistry; +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter; +import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter; +import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter; +import io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender; +import io.opentelemetry.instrumentation.micrometer.v1_5.OpenTelemetryMeterRegistry; +import io.opentelemetry.sdk.logs.SdkLoggerProvider; +import io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor; +import io.opentelemetry.sdk.metrics.SdkMeterProvider; +import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.export.BatchSpanProcessor; +import io.temporal.client.WorkflowClient; +import io.temporal.common.reporter.MicrometerClientStatsReporter; +import io.temporal.opentelemetry.v2.OpenTelemetryPlugin; +import io.temporal.opentelemetry.v2.ReplaySafeOpenTelemetry; +import io.temporal.serviceclient.WorkflowServiceStubs; +import io.temporal.serviceclient.WorkflowServiceStubsOptions; +import io.temporal.worker.WorkerFactory; + +class OpenTelemetrySetupExamples { + static ReplaySafeOpenTelemetry createOpenTelemetry() { + // @@@SNIPSTART java-opentelemetry-v2-setup + // Batch processors perform exporter I/O outside the Workflow thread. + ReplaySafeOpenTelemetry openTelemetry = + ReplaySafeOpenTelemetry.newBuilder() + .setTracerProviderBuilder( + SdkTracerProvider.builder() + .addSpanProcessor( + BatchSpanProcessor.builder(OtlpGrpcSpanExporter.builder().build()).build())) + .setMeterProviderBuilder( + SdkMeterProvider.builder() + .registerMetricReader( + PeriodicMetricReader.builder(OtlpGrpcMetricExporter.builder().build()) + .build())) + .setLoggerProviderBuilder( + SdkLoggerProvider.builder() + .addLogRecordProcessor( + BatchLogRecordProcessor.builder( + OtlpGrpcLogRecordExporter.builder().build()) + .build())) + .build(); + GlobalOpenTelemetry.set(openTelemetry); + // @@@SNIPEND + return openTelemetry; + } + + static WorkerFactory addPlugin() { + // @@@SNIPSTART java-opentelemetry-v2-plugin + OpenTelemetryPlugin plugin = OpenTelemetryPlugin.newBuilder().build(); + + WorkflowServiceStubs service = + WorkflowServiceStubs.newServiceStubs( + WorkflowServiceStubsOptions.newBuilder().setPlugins(plugin).build()); + WorkflowClient client = WorkflowClient.newInstance(service); + WorkerFactory factory = WorkerFactory.newInstance(client); + // @@@SNIPEND + return factory; + } + + static OpenTelemetryPlugin addTemporalSpans() { + // @@@SNIPSTART java-opentelemetry-v2-temporal-spans + OpenTelemetryPlugin plugin = OpenTelemetryPlugin.newBuilder().setAddTemporalSpans(true).build(); + // @@@SNIPEND + return plugin; + } + + static WorkflowServiceStubs exportSdkMetrics(ReplaySafeOpenTelemetry openTelemetry) { + // @@@SNIPSTART java-opentelemetry-v2-sdk-metrics + MeterRegistry registry = OpenTelemetryMeterRegistry.builder(openTelemetry).build(); + Scope scope = + new RootScopeBuilder() + .reporter(new MicrometerClientStatsReporter(registry)) + .reportEvery(com.uber.m3.util.Duration.ofSeconds(10)); + + WorkflowServiceStubs service = + WorkflowServiceStubs.newServiceStubs( + WorkflowServiceStubsOptions.newBuilder().setMetricsScope(scope).build()); + // @@@SNIPEND + return service; + } + + static void installLogAppender(ReplaySafeOpenTelemetry openTelemetry) { + // @@@SNIPSTART java-opentelemetry-v2-log-appender + OpenTelemetryAppender.install(openTelemetry); + // @@@SNIPEND + } + + static void shutdown(WorkerFactory factory, ReplaySafeOpenTelemetry openTelemetry) { + // @@@SNIPSTART java-opentelemetry-v2-shutdown + factory.shutdown(); + openTelemetry.close(); + // @@@SNIPEND + } +} diff --git a/java-sandbox/opentelemetry-v2/src/main/resources/logback.xml b/java-sandbox/opentelemetry-v2/src/main/resources/logback.xml new file mode 100644 index 0000000..3737f5f --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/main/resources/logback.xml @@ -0,0 +1,10 @@ + + + + + + + + + diff --git a/java-sandbox/opentelemetry-v2/src/test/java/io/temporal/docs/opentelemetryv2/GreetingWorkflowTest.java b/java-sandbox/opentelemetry-v2/src/test/java/io/temporal/docs/opentelemetryv2/GreetingWorkflowTest.java new file mode 100644 index 0000000..352c7a4 --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/test/java/io/temporal/docs/opentelemetryv2/GreetingWorkflowTest.java @@ -0,0 +1,119 @@ +package io.temporal.docs.opentelemetryv2; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender; +import io.opentelemetry.sdk.logs.SdkLoggerProvider; +import io.opentelemetry.sdk.logs.data.LogRecordData; +import io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor; +import io.opentelemetry.sdk.metrics.SdkMeterProvider; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter; +import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; +import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.data.SpanData; +import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor; +import io.temporal.client.WorkflowOptions; +import io.temporal.opentelemetry.v2.OpenTelemetryPlugin; +import io.temporal.opentelemetry.v2.ReplaySafeOpenTelemetry; +import io.temporal.serviceclient.WorkflowServiceStubsOptions; +import io.temporal.testing.TestEnvironmentOptions; +import io.temporal.testing.TestWorkflowEnvironment; +import io.temporal.worker.Worker; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +public class GreetingWorkflowTest { + private static final String TASK_QUEUE = "opentelemetry-v2-test"; + + private static final InMemorySpanExporter spanExporter = InMemorySpanExporter.create(); + private static final InMemoryMetricReader metricReader = InMemoryMetricReader.create(); + private static final InMemoryLogRecordExporter logExporter = InMemoryLogRecordExporter.create(); + private static ReplaySafeOpenTelemetry openTelemetry; + + @BeforeAll + static void registerOpenTelemetry() { + openTelemetry = + ReplaySafeOpenTelemetry.newBuilder() + .setTracerProviderBuilder( + SdkTracerProvider.builder() + .addSpanProcessor(SimpleSpanProcessor.create(spanExporter))) + .setMeterProviderBuilder(SdkMeterProvider.builder().registerMetricReader(metricReader)) + .setLoggerProviderBuilder( + SdkLoggerProvider.builder() + .addLogRecordProcessor(SimpleLogRecordProcessor.create(logExporter))) + .build(); + GlobalOpenTelemetry.set(openTelemetry); + OpenTelemetryAppender.install(openTelemetry); + } + + @AfterAll + static void resetOpenTelemetry() { + GlobalOpenTelemetry.resetForTest(); + openTelemetry.close(); + } + + @Test + void emitsSpansMetricsAndLogs() { + TestEnvironmentOptions options = + TestEnvironmentOptions.newBuilder() + .setWorkflowServiceStubsOptions( + WorkflowServiceStubsOptions.newBuilder() + .setPlugins(OpenTelemetryPlugin.newBuilder().setAddTemporalSpans(true).build()) + .build()) + .build(); + try (TestWorkflowEnvironment testEnv = TestWorkflowEnvironment.newInstance(options)) { + Worker worker = testEnv.newWorker(TASK_QUEUE); + worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class); + worker.registerActivitiesImplementations(new GreetingActivitiesImpl()); + testEnv.start(); + + GreetingWorkflow workflow = + testEnv + .getWorkflowClient() + .newWorkflowStub( + GreetingWorkflow.class, + WorkflowOptions.newBuilder().setTaskQueue(TASK_QUEUE).build()); + + assertEquals("Hello, Temporal!", workflow.greet("Temporal")); + } + + Map spans = + spanExporter.getFinishedSpanItems().stream() + .collect(Collectors.toMap(SpanData::getName, Function.identity(), (a, b) -> a)); + SpanData runWorkflow = spans.get("RunWorkflow:GreetingWorkflow"); + SpanData requestGreeting = spans.get("request-greeting"); + SpanData runActivity = spans.get("RunActivity:ComposeGreeting"); + SpanData formatGreeting = spans.get("format-greeting"); + assertEquals(runWorkflow.getSpanId(), requestGreeting.getParentSpanId()); + assertEquals(runActivity.getSpanId(), formatGreeting.getParentSpanId()); + assertEquals(runWorkflow.getTraceId(), formatGreeting.getTraceId()); + + MetricData counter = + metricReader.collectAllMetrics().stream() + .filter(metric -> metric.getName().equals("greeting.workflow.runs")) + .findFirst() + .orElseThrow(); + assertEquals(1, counter.getLongSumData().getPoints().iterator().next().getValue()); + + List logs = logExporter.getFinishedLogRecordItems(); + LogRecordData workflowLog = + logs.stream() + .filter(log -> log.getBodyValue().asString().equals("Requesting greeting for Temporal")) + .findFirst() + .orElseThrow(); + assertEquals(runWorkflow.getSpanId(), workflowLog.getSpanContext().getSpanId()); + assertTrue( + logs.stream() + .anyMatch( + log -> log.getBodyValue().asString().equals("Formatting greeting for Temporal"))); + } +} diff --git a/java-sandbox/opentelemetry-v2/src/test/resources/logback-test.xml b/java-sandbox/opentelemetry-v2/src/test/resources/logback-test.xml new file mode 100644 index 0000000..a33661b --- /dev/null +++ b/java-sandbox/opentelemetry-v2/src/test/resources/logback-test.xml @@ -0,0 +1,19 @@ + + + + %d{HH:mm:ss.SSS} %-5level [%thread] %logger{36} - %msg%n + + + + + + + + + + + + + +