diff --git a/README.md b/README.md index b70a9098..ca979617 100644 --- a/README.md +++ b/README.md @@ -162,6 +162,8 @@ Load client configuration from TOML files with programmatic overrides. - [**Set up OpenTracing and/or OpenTelemetry with Jaeger**](/core/src/main/java/io/temporal/samples/tracing): Demonstrates how to set up OpenTracing and/or OpenTelemetry and view traces using Jaeger. +- [**OpenTelemetry v2**](/opentelemetry-v2): Demonstrates replay-safe instrumentation with the experimental `temporal-opentelemetry-v2` plugin. + #### Encryption Support - [**Encrypted Payloads**](/core/src/main/java/io/temporal/samples/encryptedpayloads): Demonstrates how to use simple codec to encrypt and decrypt payloads. diff --git a/opentelemetry-v2/README.md b/opentelemetry-v2/README.md new file mode 100644 index 00000000..d2dfae47 --- /dev/null +++ b/opentelemetry-v2/README.md @@ -0,0 +1,11 @@ +# OpenTelemetry v2 + +These samples use the +[OpenTelemetry v2 plugin](https://github.com/temporalio/sdk-java/tree/master/contrib/temporal-opentelemetry-v2) +for replay-safe instrumentation. + +## Samples + +- [Traces](src/main/java/io/temporal/samples/opentelemetryv2/traces) +- [Metrics](src/main/java/io/temporal/samples/opentelemetryv2/metrics) +- [Logs](src/main/java/io/temporal/samples/opentelemetryv2/logs) diff --git a/opentelemetry-v2/build.gradle b/opentelemetry-v2/build.gradle new file mode 100644 index 00000000..d20c7c75 --- /dev/null +++ b/opentelemetry-v2/build.gradle @@ -0,0 +1,31 @@ +repositories { + // temporal-opentelemetry-v2 is not released yet. Publish it with + // ./gradlew publishToMavenLocal from sdk-java. + mavenLocal() +} + +ext { + temporalOtelV2Version = '1.41.0-SNAPSHOT' +} + +dependencies { + implementation "io.temporal:temporal-sdk:$temporalOtelV2Version" + implementation "io.temporal:temporal-envconfig:$temporalOtelV2Version" + implementation "io.temporal:temporal-opentelemetry-v2:$temporalOtelV2Version" + implementation "io.opentelemetry:opentelemetry-exporter-otlp" + implementation "io.opentelemetry:opentelemetry-exporter-prometheus:1.66.0-alpha" + implementation "io.opentelemetry.instrumentation:opentelemetry-micrometer-1.5:2.32.0-alpha" + implementation "io.opentelemetry:opentelemetry-exporter-logging" + implementation "io.opentelemetry.instrumentation:opentelemetry-logback-appender-1.0:2.32.0-alpha" + implementation group: 'ch.qos.logback', name: 'logback-classic', version: '1.5.6' + + dependencies { + errorproneJavac('com.google.errorprone:javac:9+181-r4173-1') + errorprone('com.google.errorprone:error_prone_core:2.28.0') + } +} + +task execute(type: JavaExec) { + mainClass = findProperty("mainClass") ?: "" + classpath = sourceSets.main.runtimeClasspath +} diff --git a/opentelemetry-v2/docker-compose.yaml b/opentelemetry-v2/docker-compose.yaml new file mode 100644 index 00000000..8f9f5ec8 --- /dev/null +++ b/opentelemetry-v2/docker-compose.yaml @@ -0,0 +1,6 @@ +services: + jaeger: + image: jaegertracing/jaeger:2.20.0 + ports: + - "127.0.0.1:4317:4317" + - "127.0.0.1:16686:16686" diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingActivities.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingActivities.java new file mode 100644 index 00000000..c81bbf97 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingActivities.java @@ -0,0 +1,8 @@ +package io.temporal.samples.opentelemetryv2.logs; + +import io.temporal.activity.ActivityInterface; + +@ActivityInterface +public interface GreetingActivities { + String composeGreeting(String name); +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingActivitiesImpl.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingActivitiesImpl.java new file mode 100644 index 00000000..868dde60 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingActivitiesImpl.java @@ -0,0 +1,14 @@ +package io.temporal.samples.opentelemetryv2.logs; + +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); + return "Hello, " + name + "!"; + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingWorkflow.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingWorkflow.java new file mode 100644 index 00000000..5eb14203 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingWorkflow.java @@ -0,0 +1,10 @@ +package io.temporal.samples.opentelemetryv2.logs; + +import io.temporal.workflow.WorkflowInterface; +import io.temporal.workflow.WorkflowMethod; + +@WorkflowInterface +public interface GreetingWorkflow { + @WorkflowMethod + String greet(String name); +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingWorkflowImpl.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingWorkflowImpl.java new file mode 100644 index 00000000..a86468b0 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/GreetingWorkflowImpl.java @@ -0,0 +1,21 @@ +package io.temporal.samples.opentelemetryv2.logs; + +import io.temporal.activity.ActivityOptions; +import io.temporal.workflow.Workflow; +import java.time.Duration; +import org.slf4j.Logger; + +public class GreetingWorkflowImpl implements GreetingWorkflow { + private static final Logger logger = Workflow.getLogger(GreetingWorkflowImpl.class); + + private final GreetingActivities activities = + Workflow.newActivityStub( + GreetingActivities.class, + ActivityOptions.newBuilder().setStartToCloseTimeout(Duration.ofSeconds(10)).build()); + + @Override + public String greet(String name) { + logger.info("Requesting greeting for {}", name); + return activities.composeGreeting(name); + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/LogsWorker.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/LogsWorker.java new file mode 100644 index 00000000..7da4a78c --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/LogsWorker.java @@ -0,0 +1,84 @@ +package io.temporal.samples.opentelemetryv2.logs; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.exporter.logging.SystemOutLogRecordExporter; +import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter; +import io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender; +import io.opentelemetry.sdk.logs.SdkLoggerProvider; +import io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor; +import io.opentelemetry.sdk.resources.Resource; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.export.BatchSpanProcessor; +import io.temporal.client.WorkflowClient; +import io.temporal.envconfig.ClientConfigProfile; +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.Worker; +import io.temporal.worker.WorkerFactory; +import java.io.IOException; + +public class LogsWorker { + static final String TASK_QUEUE = "logs"; + private static final String SERVICE_NAME = "temporal-otel-v2-logs-worker"; + + public static void main(String[] args) throws IOException { + Resource resource = Resource.getDefault().toBuilder().put("service.name", SERVICE_NAME).build(); + + // Log records are printed to the console with the trace and span IDs of the span that was + // current when they were logged. Spans also go to Jaeger, where you can look up a trace ID. + // Batch processors perform exporter I/O outside the Workflow thread. + ReplaySafeOpenTelemetry openTelemetry = + ReplaySafeOpenTelemetry.newBuilder() + .setTracerProviderBuilder( + SdkTracerProvider.builder() + .addSpanProcessor( + BatchSpanProcessor.builder( + OtlpGrpcSpanExporter.builder() + .setEndpoint("http://127.0.0.1:4317") + .build()) + .build()) + .setResource(resource)) + .setLoggerProviderBuilder( + SdkLoggerProvider.builder() + .addLogRecordProcessor( + BatchLogRecordProcessor.builder(SystemOutLogRecordExporter.create()) + .build()) + .setResource(resource)) + .build(); + GlobalOpenTelemetry.set(openTelemetry); + + // Sends SLF4J logs from this package to OpenTelemetry. See logback.xml. + OpenTelemetryAppender.install(openTelemetry); + + OpenTelemetryPlugin plugin = + OpenTelemetryPlugin.newBuilder() + // Adds Temporal SDK operation spans. Log records take the trace and span IDs of the + // span that is current when they are logged. + .setAddTemporalSpans(true) + .build(); + + ClientConfigProfile profile = ClientConfigProfile.load(); + WorkflowServiceStubs service = + WorkflowServiceStubs.newServiceStubs( + WorkflowServiceStubsOptions.newBuilder(profile.toWorkflowServiceStubsOptions()) + .setPlugins(plugin) + .build()); + WorkflowClient client = WorkflowClient.newInstance(service, profile.toWorkflowClientOptions()); + + WorkerFactory factory = WorkerFactory.newInstance(client); + Worker worker = factory.newWorker(TASK_QUEUE); + worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class); + worker.registerActivitiesImplementations(new GreetingActivitiesImpl()); + + Runtime.getRuntime() + .addShutdownHook( + new Thread( + () -> { + factory.shutdown(); + openTelemetry.close(); + })); + factory.start(); + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/README.md b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/README.md new file mode 100644 index 00000000..d1913552 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/logs/README.md @@ -0,0 +1,42 @@ +## Logs + +This sample instruments a Workflow and an Activity to emit logs. Each log +record carries the trace ID and span ID of the span it was logged in. + +It turns on Temporal SDK operation spans with `setAddTemporalSpans(true)` in +[`LogsWorker.java`](LogsWorker.java), so the logs have spans to join. + +### Run the sample + +1. Run a [Temporal Service](../../../../../../../../../README.md#running-samples). + +2. Start the Worker: + +```bash +./gradlew -q :opentelemetry-v2:execute -PmainClass=io.temporal.samples.opentelemetryv2.logs.LogsWorker +``` + +3. In another terminal, start the Workflow: + +```bash +temporal workflow execute \ + --task-queue logs \ + --type GreetingWorkflow \ + --input '"Temporal"' +``` + +4. The Worker prints each log record with its trace ID and span ID: + +```text +INFO 'Requesting greeting for Temporal' : ed5a47978eb89fb2f492172747a5ede9 996ada643cb7ee95 [scopeInfo: io.temporal.samples.opentelemetryv2.logs.GreetingWorkflowImpl:] {} +INFO 'Formatting greeting for Temporal' : ed5a47978eb89fb2f492172747a5ede9 17d77396b969503a [scopeInfo: io.temporal.samples.opentelemetryv2.logs.GreetingActivitiesImpl:] {} +``` + + The IDs are different on every run. Within a run, both records share one + trace ID, and each has its own span ID. + + The Worker also exports spans to Jaeger. If Jaeger is running, as in the + [traces sample](../traces), search for your trace ID in the + [Jaeger UI](http://127.0.0.1:16686). The Workflow log's span ID matches the + `RunWorkflow:GreetingWorkflow` span, and the Activity log's span ID matches + the `RunActivity:ComposeGreeting` span. diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingActivities.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingActivities.java new file mode 100644 index 00000000..02092ccf --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingActivities.java @@ -0,0 +1,8 @@ +package io.temporal.samples.opentelemetryv2.metrics; + +import io.temporal.activity.ActivityInterface; + +@ActivityInterface +public interface GreetingActivities { + String composeGreeting(String name); +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingActivitiesImpl.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingActivitiesImpl.java new file mode 100644 index 00000000..b3a36ebe --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingActivitiesImpl.java @@ -0,0 +1,16 @@ +package io.temporal.samples.opentelemetryv2.metrics; + +import io.opentelemetry.api.GlobalOpenTelemetry; + +public class GreetingActivitiesImpl implements GreetingActivities { + @Override + public String composeGreeting(String name) { + GlobalOpenTelemetry.getMeter(GreetingWorkflowImpl.INSTRUMENTATION_NAME) + .counterBuilder("greeting.activity.runs") + .setDescription("Number of times the greeting Activity has run") + .setUnit("{run}") + .build() + .add(1); + return "Hello, " + name + "!"; + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingWorkflow.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingWorkflow.java new file mode 100644 index 00000000..fc377fbc --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingWorkflow.java @@ -0,0 +1,10 @@ +package io.temporal.samples.opentelemetryv2.metrics; + +import io.temporal.workflow.WorkflowInterface; +import io.temporal.workflow.WorkflowMethod; + +@WorkflowInterface +public interface GreetingWorkflow { + @WorkflowMethod + String greet(String name); +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingWorkflowImpl.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingWorkflowImpl.java new file mode 100644 index 00000000..48f50252 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/GreetingWorkflowImpl.java @@ -0,0 +1,26 @@ +package io.temporal.samples.opentelemetryv2.metrics; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.temporal.activity.ActivityOptions; +import io.temporal.workflow.Workflow; +import java.time.Duration; + +public class GreetingWorkflowImpl implements GreetingWorkflow { + static final String INSTRUMENTATION_NAME = "io.temporal.samples.opentelemetryv2.metrics"; + + private final GreetingActivities activities = + Workflow.newActivityStub( + GreetingActivities.class, + ActivityOptions.newBuilder().setStartToCloseTimeout(Duration.ofSeconds(10)).build()); + + @Override + public String greet(String name) { + GlobalOpenTelemetry.getMeter(INSTRUMENTATION_NAME) + .counterBuilder("greeting.workflow.runs") + .setDescription("Number of times the greeting Workflow has run") + .setUnit("{run}") + .build() + .add(1); + return activities.composeGreeting(name); + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/MetricsWorker.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/MetricsWorker.java new file mode 100644 index 00000000..b0861c3c --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/MetricsWorker.java @@ -0,0 +1,84 @@ +package io.temporal.samples.opentelemetryv2.metrics; + +import com.uber.m3.tally.RootScopeBuilder; +import com.uber.m3.tally.Scope; +import com.uber.m3.tally.ScopeCloseException; +import io.micrometer.core.instrument.MeterRegistry; +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.exporter.prometheus.PrometheusHttpServer; +import io.opentelemetry.instrumentation.micrometer.v1_5.OpenTelemetryMeterRegistry; +import io.opentelemetry.sdk.metrics.SdkMeterProvider; +import io.opentelemetry.sdk.resources.Resource; +import io.temporal.client.WorkflowClient; +import io.temporal.common.reporter.MicrometerClientStatsReporter; +import io.temporal.envconfig.ClientConfigProfile; +import io.temporal.opentelemetry.v2.ReplaySafeOpenTelemetry; +import io.temporal.serviceclient.WorkflowServiceStubs; +import io.temporal.serviceclient.WorkflowServiceStubsOptions; +import io.temporal.worker.Worker; +import io.temporal.worker.WorkerFactory; +import java.io.IOException; +import java.util.concurrent.TimeUnit; + +public class MetricsWorker { + static final String TASK_QUEUE = "metrics"; + private static final String SERVICE_NAME = "temporal-otel-v2-metrics-worker"; + + public static void main(String[] args) throws IOException { + // Serves recorded metrics in Prometheus format at http://127.0.0.1:9090/metrics. + PrometheusHttpServer prometheus = + PrometheusHttpServer.builder().setHost("127.0.0.1").setPort(9090).build(); + + // Meters from this global drop recordings made while a Workflow replays. + ReplaySafeOpenTelemetry openTelemetry = + ReplaySafeOpenTelemetry.newBuilder() + .setMeterProviderBuilder( + SdkMeterProvider.builder() + .registerMetricReader(prometheus) + .setResource( + Resource.getDefault().toBuilder() + .put("service.name", SERVICE_NAME) + .build())) + .build(); + GlobalOpenTelemetry.set(openTelemetry); + + // The SDK reports its own metrics through Tally. Micrometer bridges them into OpenTelemetry, + // so they are served next to the custom counters. + MeterRegistry registry = OpenTelemetryMeterRegistry.builder(openTelemetry).build(); + Scope scope = + new RootScopeBuilder() + .reporter(new MicrometerClientStatsReporter(registry)) + .reportEvery(com.uber.m3.util.Duration.ofSeconds(1)); + + ClientConfigProfile profile = ClientConfigProfile.load(); + WorkflowServiceStubs service = + WorkflowServiceStubs.newServiceStubs( + WorkflowServiceStubsOptions.newBuilder(profile.toWorkflowServiceStubsOptions()) + // Exports Temporal SDK metrics, such as temporal_workflow_completed. + // Comment out this line to turn them off and keep only the custom counters. + .setMetricsScope(scope) + .build()); + WorkflowClient client = WorkflowClient.newInstance(service, profile.toWorkflowClientOptions()); + + WorkerFactory factory = WorkerFactory.newInstance(client); + Worker worker = factory.newWorker(TASK_QUEUE); + worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class); + worker.registerActivitiesImplementations(new GreetingActivitiesImpl()); + + Runtime.getRuntime() + .addShutdownHook( + new Thread( + () -> { + factory.shutdown(); + factory.awaitTermination(10, TimeUnit.SECONDS); + // Closing the scope sends its last report before OpenTelemetry closes. + try { + scope.close(); + } catch (ScopeCloseException e) { + throw new RuntimeException(e); + } + openTelemetry.close(); + })); + factory.start(); + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/README.md b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/README.md new file mode 100644 index 00000000..ed4c4aaf --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/metrics/README.md @@ -0,0 +1,38 @@ +## Metrics + +This sample instruments a Workflow and an Activity to emit metrics. + +By default, it also exports Temporal SDK metrics with `setMetricsScope(scope)` +in [`MetricsWorker.java`](MetricsWorker.java). Comment out that line to turn +them off and keep only the custom counters. + + +### Run the sample + +1. Run a [Temporal Service](../../../../../../../../../README.md#running-samples). + +2. Start the Worker: + +```bash +./gradlew -q :opentelemetry-v2:execute -PmainClass=io.temporal.samples.opentelemetryv2.metrics.MetricsWorker +``` + +3. In another terminal, start the Workflow: + +```bash +temporal workflow execute \ + --task-queue metrics \ + --type GreetingWorkflow \ + --input '"Temporal"' +``` + +4. Open the [metrics endpoint](http://127.0.0.1:9090/metrics). It shows the + custom `greeting_workflow_runs_total` and `greeting_activity_runs_total` + counters. With SDK metrics on, it also shows Temporal SDK metrics, such as + `temporal_workflow_completed_total` and + `temporal_activity_execution_latency_seconds`. + +```text +greeting_activity_runs_total{otel_scope_name="io.temporal.samples.opentelemetryv2.metrics"} 1.0 +greeting_workflow_runs_total{otel_scope_name="io.temporal.samples.opentelemetryv2.metrics"} 1.0 +``` diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingActivities.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingActivities.java new file mode 100644 index 00000000..ad094038 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingActivities.java @@ -0,0 +1,8 @@ +package io.temporal.samples.opentelemetryv2.traces; + +import io.temporal.activity.ActivityInterface; + +@ActivityInterface +public interface GreetingActivities { + String composeGreeting(String name); +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingActivitiesImpl.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingActivitiesImpl.java new file mode 100644 index 00000000..b356ee09 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingActivitiesImpl.java @@ -0,0 +1,20 @@ +package io.temporal.samples.opentelemetryv2.traces; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Scope; + +public class GreetingActivitiesImpl implements GreetingActivities { + @Override + public String composeGreeting(String 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/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingWorkflow.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingWorkflow.java new file mode 100644 index 00000000..3323cc91 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingWorkflow.java @@ -0,0 +1,10 @@ +package io.temporal.samples.opentelemetryv2.traces; + +import io.temporal.workflow.WorkflowInterface; +import io.temporal.workflow.WorkflowMethod; + +@WorkflowInterface +public interface GreetingWorkflow { + @WorkflowMethod + String greet(String name); +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingWorkflowImpl.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingWorkflowImpl.java new file mode 100644 index 00000000..320d4e53 --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/GreetingWorkflowImpl.java @@ -0,0 +1,30 @@ +package io.temporal.samples.opentelemetryv2.traces; + +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; + +public class GreetingWorkflowImpl implements GreetingWorkflow { + static final String INSTRUMENTATION_NAME = "io.temporal.samples.opentelemetryv2.traces"; + + private final GreetingActivities activities = + Workflow.newActivityStub( + GreetingActivities.class, + ActivityOptions.newBuilder().setStartToCloseTimeout(Duration.ofSeconds(10)).build()); + + @Override + public String greet(String name) { + Span span = + GlobalOpenTelemetry.getTracer(INSTRUMENTATION_NAME) + .spanBuilder("request-greeting") + .startSpan(); + try (Scope ignored = span.makeCurrent()) { + return activities.composeGreeting(name); + } finally { + span.end(); + } + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/README.md b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/README.md new file mode 100644 index 00000000..4d692b6e --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/README.md @@ -0,0 +1,41 @@ +## Traces + +This sample instruments a Workflow and an Activity to emit traces. + +By default, it also turns on Temporal SDK operation spans with +`setAddTemporalSpans(true)` in +[`TracesWorker.java`](TracesWorker.java). Comment out that line to turn them +off and keep only the custom spans. + +### Run the sample + +1. Run a [Temporal Service](../../../../../../../../../README.md#running-samples). + +2. Start Jaeger from the repository root: + +```bash +docker compose -f opentelemetry-v2/docker-compose.yaml up -d +``` + +3. Start the Worker: + +```bash +./gradlew -q :opentelemetry-v2:execute -PmainClass=io.temporal.samples.opentelemetryv2.traces.TracesWorker +``` + +4. In another terminal, start the Workflow: + +```bash +temporal workflow execute \ + --task-queue traces \ + --type GreetingWorkflow \ + --input '"Temporal"' +``` + +5. Inspect the `temporal-otel-v2-traces-worker` service in the + [Jaeger UI](http://127.0.0.1:16686). The trace shows the custom + `request-greeting` and `format-greeting` spans. With Temporal spans on, it + also shows `RunWorkflow:GreetingWorkflow`, `StartActivity:ComposeGreeting`, + and `RunActivity:ComposeGreeting`. + + ![Jaeger trace with custom and Temporal SDK operation spans](result.png) diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/TracesWorker.java b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/TracesWorker.java new file mode 100644 index 00000000..4e088dce --- /dev/null +++ b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/TracesWorker.java @@ -0,0 +1,70 @@ +package io.temporal.samples.opentelemetryv2.traces; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter; +import io.opentelemetry.sdk.resources.Resource; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.export.BatchSpanProcessor; +import io.temporal.client.WorkflowClient; +import io.temporal.envconfig.ClientConfigProfile; +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.Worker; +import io.temporal.worker.WorkerFactory; +import java.io.IOException; + +public class TracesWorker { + static final String TASK_QUEUE = "traces"; + private static final String SERVICE_NAME = "temporal-otel-v2-traces-worker"; + + public static void main(String[] args) throws IOException { + OtlpGrpcSpanExporter exporter = + OtlpGrpcSpanExporter.builder().setEndpoint("http://127.0.0.1:4317").build(); + + // The plugin requires a replay-safe OpenTelemetry instance registered as the global. + ReplaySafeOpenTelemetry openTelemetry = + ReplaySafeOpenTelemetry.newBuilder() + .setTracerProviderBuilder( + SdkTracerProvider.builder() + // BatchSpanProcessor performs exporter I/O outside the Workflow thread. + .addSpanProcessor(BatchSpanProcessor.builder(exporter).build()) + .setResource( + Resource.getDefault().toBuilder() + .put("service.name", SERVICE_NAME) + .build())) + .build(); + GlobalOpenTelemetry.set(openTelemetry); + + OpenTelemetryPlugin plugin = + OpenTelemetryPlugin.newBuilder() + // Adds Temporal SDK operation spans, such as RunWorkflow and RunActivity. + // Comment out this line to turn them off and keep only the custom spans. + .setAddTemporalSpans(true) + .build(); + + // Service stubs that carry the plugin pass it to their client and Workers. + ClientConfigProfile profile = ClientConfigProfile.load(); + WorkflowServiceStubs service = + WorkflowServiceStubs.newServiceStubs( + WorkflowServiceStubsOptions.newBuilder(profile.toWorkflowServiceStubsOptions()) + .setPlugins(plugin) + .build()); + WorkflowClient client = WorkflowClient.newInstance(service, profile.toWorkflowClientOptions()); + + WorkerFactory factory = WorkerFactory.newInstance(client); + Worker worker = factory.newWorker(TASK_QUEUE); + worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class); + worker.registerActivitiesImplementations(new GreetingActivitiesImpl()); + + Runtime.getRuntime() + .addShutdownHook( + new Thread( + () -> { + factory.shutdown(); + openTelemetry.close(); + })); + factory.start(); + } +} diff --git a/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/result.png b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/result.png new file mode 100644 index 00000000..f5f65ce4 Binary files /dev/null and b/opentelemetry-v2/src/main/java/io/temporal/samples/opentelemetryv2/traces/result.png differ diff --git a/opentelemetry-v2/src/main/resources/logback.xml b/opentelemetry-v2/src/main/resources/logback.xml new file mode 100644 index 00000000..531d63fd --- /dev/null +++ b/opentelemetry-v2/src/main/resources/logback.xml @@ -0,0 +1,21 @@ + + + + %d{HH:mm:ss.SSS} %-5level [%thread] %logger{36} - %msg%n + + + + + + + + + + + + + + + + diff --git a/settings.gradle b/settings.gradle index e66f00a2..2f590735 100644 --- a/settings.gradle +++ b/settings.gradle @@ -10,3 +10,4 @@ include 'springboot-basic' include 'lambda-worker:starter' include 'lambda-worker:worker' include 'gcp:cloud-run' +include 'opentelemetry-v2'