Deprecated methods are delegated directly without any observation.
+ */
+public class ObservationDaprClient implements DaprClient {
+
+ private final DaprClient delegate;
+ private final ObservationRegistry observationRegistry;
+
+ /**
+ * Creates a new {@code ObservationDaprClient}.
+ *
+ * @param delegate the underlying {@link DaprClient} to delegate calls to
+ * @param observationRegistry the Micrometer {@link ObservationRegistry} used to create spans
+ */
+ public ObservationDaprClient(DaprClient delegate, ObservationRegistry observationRegistry) {
+ this.delegate = delegate;
+ this.observationRegistry = observationRegistry;
+ }
+
+ // -------------------------------------------------------------------------
+ // Internal helpers
+ // -------------------------------------------------------------------------
+
+ private Because this class extends {@link DaprWorkflowClient}, consumers can keep injecting
+ * {@code DaprWorkflowClient} without any code changes. Deprecated methods fall through to the
+ * parent implementation without any observation.
+ *
+ * Constructor note: calling {@code super(properties)} eagerly creates a gRPC
+ * {@code ManagedChannel}, but the actual TCP connection is established lazily on the first RPC call,
+ * so construction succeeds even when the Dapr sidecar is not yet available.
+ */
+public class ObservationDaprWorkflowClient extends DaprWorkflowClient {
+
+ private final ObservationRegistry observationRegistry;
+
+ /**
+ * Creates a new {@code ObservationDaprWorkflowClient}.
+ *
+ * @param properties connection properties for the underlying gRPC channel
+ * @param observationRegistry the Micrometer {@link ObservationRegistry} used to create spans
+ */
+ public ObservationDaprWorkflowClient(Properties properties,
+ ObservationRegistry observationRegistry) {
+ super(properties);
+ this.observationRegistry = observationRegistry;
+ }
+
+ // -------------------------------------------------------------------------
+ // Internal helpers
+ // -------------------------------------------------------------------------
+
+ private Observation observation(String name) {
+ return Observation.createNotStarted(name, observationRegistry);
+ }
+
+ // -------------------------------------------------------------------------
+ // scheduleNewWorkflow — only String-based "leaf" overloads are overridden.
+ // Class
Deprecated methods are delegated directly without any observation.
+ */
+public class ObservationDaprClient implements DaprClient {
+
+ private final DaprClient delegate;
+ private final ObservationRegistry observationRegistry;
+
+ /**
+ * Creates a new {@code ObservationDaprClient}.
+ *
+ * @param delegate the underlying {@link DaprClient} to delegate calls to
+ * @param observationRegistry the Micrometer {@link ObservationRegistry} used to create spans
+ */
+ public ObservationDaprClient(DaprClient delegate, ObservationRegistry observationRegistry) {
+ this.delegate = delegate;
+ this.observationRegistry = observationRegistry;
+ }
+
+ // -------------------------------------------------------------------------
+ // Internal helpers
+ // -------------------------------------------------------------------------
+
+ private Because this class extends {@link DaprWorkflowClient}, consumers can keep injecting
+ * {@code DaprWorkflowClient} without any code changes. Deprecated methods fall through to the
+ * parent implementation without any observation.
+ *
+ * Constructor note: calling {@code super(properties)} eagerly creates a gRPC
+ * {@code ManagedChannel}, but the actual TCP connection is established lazily on the first RPC call,
+ * so construction succeeds even when the Dapr sidecar is not yet available.
+ */
+public class ObservationDaprWorkflowClient extends DaprWorkflowClient {
+
+ private final ObservationRegistry observationRegistry;
+
+ /**
+ * Creates a new {@code ObservationDaprWorkflowClient}.
+ *
+ * @param properties connection properties for the underlying gRPC channel
+ * @param observationRegistry the Micrometer {@link ObservationRegistry} used to create spans
+ */
+ public ObservationDaprWorkflowClient(Properties properties,
+ ObservationRegistry observationRegistry) {
+ super(properties);
+ this.observationRegistry = observationRegistry;
+ }
+
+ // -------------------------------------------------------------------------
+ // Internal helpers
+ // -------------------------------------------------------------------------
+
+ private Observation observation(String name) {
+ return Observation.createNotStarted(name, observationRegistry);
+ }
+
+ // -------------------------------------------------------------------------
+ // scheduleNewWorkflow — only String-based "leaf" overloads are overridden.
+ // Class Verifies two key requirements:
+ * Verifies two key requirements:
+ * The gRPC {@code ManagedChannel} created in the parent constructor connects lazily, so
+ * instantiation succeeds without a running Dapr sidecar. Actual RPC calls will fail, but the
+ * observation lifecycle (start → error → stop) is still validated.
+ *
+ * Verifies two key requirements:
+ *
+ *
+ */
+class DaprClientObservationAutoConfigurationTest {
+
+ private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
+ .withConfiguration(AutoConfigurations.of(DaprClientAutoConfiguration.class));
+
+ // -------------------------------------------------------------------------
+ // Without ObservationRegistry — plain beans
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("DaprClient is a plain client when no ObservationRegistry is present")
+ void daprClientIsPlainWhenNoRegistry() {
+ contextRunner
+ .withBean(DaprClientBuilder.class, () -> mockBuilderReturningMockClient())
+ .run(context -> {
+ assertThat(context).hasSingleBean(DaprClient.class);
+ assertThat(context.getBean(DaprClient.class))
+ .isNotInstanceOf(ObservationDaprClient.class);
+ });
+ }
+
+ // -------------------------------------------------------------------------
+ // With ObservationRegistry — wrapped beans
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("DaprClient is ObservationDaprClient when a non-noop ObservationRegistry is present")
+ void daprClientIsObservationWrappedWhenRegistryPresent() {
+ contextRunner
+ .withBean(DaprClientBuilder.class, () -> mockBuilderReturningMockClient())
+ .withBean(ObservationRegistry.class, TestObservationRegistry::create)
+ .run(context -> {
+ assertThat(context).hasSingleBean(DaprClient.class);
+ assertThat(context.getBean(DaprClient.class))
+ .isInstanceOf(ObservationDaprClient.class);
+ });
+ }
+
+ @Test
+ @DisplayName("DaprWorkflowClient is ObservationDaprWorkflowClient when a non-noop registry is present")
+ void daprWorkflowClientIsObservationWrappedWhenRegistryPresent() {
+ contextRunner
+ .withBean(DaprClientBuilder.class, () -> mockBuilderReturningMockClient())
+ .withBean(ObservationRegistry.class, TestObservationRegistry::create)
+ .run(context -> {
+ assertThat(context).hasSingleBean(DaprWorkflowClient.class);
+ assertThat(context.getBean(DaprWorkflowClient.class))
+ .isInstanceOf(ObservationDaprWorkflowClient.class);
+ });
+ }
+
+ // -------------------------------------------------------------------------
+ // Transparency — beans remain injectable by base type
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("Consumers can inject DaprClient by its base type regardless of wrapping")
+ void daprClientInjectableByBaseType() {
+ contextRunner
+ .withBean(DaprClientBuilder.class, () -> mockBuilderReturningMockClient())
+ .withBean(ObservationRegistry.class, TestObservationRegistry::create)
+ .run(context -> {
+ // Injecting as DaprClient works — no ClassCastException, no code changes needed
+ DaprClient client = context.getBean(DaprClient.class);
+ assertThat(client).isNotNull();
+ assertThat(client).isInstanceOf(DaprClient.class);
+ });
+ }
+
+ @Test
+ @DisplayName("Consumers can inject DaprWorkflowClient by its base type regardless of wrapping")
+ void daprWorkflowClientInjectableByBaseType() {
+ contextRunner
+ .withBean(DaprClientBuilder.class, () -> mockBuilderReturningMockClient())
+ .withBean(ObservationRegistry.class, TestObservationRegistry::create)
+ .run(context -> {
+ // Injecting as DaprWorkflowClient works — ObservationDaprWorkflowClient IS-A DaprWorkflowClient
+ DaprWorkflowClient workflowClient = context.getBean(DaprWorkflowClient.class);
+ assertThat(workflowClient).isNotNull();
+ assertThat(workflowClient).isInstanceOf(DaprWorkflowClient.class);
+ });
+ }
+
+ @Test
+ @DisplayName("Noop ObservationRegistry results in plain (unwrapped) DaprClient")
+ void noopRegistryResultsInPlainClient() {
+ contextRunner
+ .withBean(DaprClientBuilder.class, () -> mockBuilderReturningMockClient())
+ .withBean(ObservationRegistry.class, ObservationRegistry::create) // NOOP registry
+ .run(context -> {
+ assertThat(context).hasSingleBean(DaprClient.class);
+ assertThat(context.getBean(DaprClient.class))
+ .isNotInstanceOf(ObservationDaprClient.class);
+ });
+ }
+
+ @Test
+ @DisplayName("User-provided DaprClient bean is not replaced by autoconfiguration")
+ void userProvidedDaprClientIsNotReplaced() {
+ DaprClient userClient = mock(DaprClient.class);
+ contextRunner
+ .withBean(ObservationRegistry.class, TestObservationRegistry::create)
+ .withBean(DaprClient.class, () -> userClient)
+ .run(context -> {
+ assertThat(context).hasSingleBean(DaprClient.class);
+ assertThat(context.getBean(DaprClient.class)).isSameAs(userClient);
+ });
+ }
+
+ // -------------------------------------------------------------------------
+ // Helpers
+ // -------------------------------------------------------------------------
+
+ private static DaprClientBuilder mockBuilderReturningMockClient() {
+ DaprClientBuilder builder = mock(DaprClientBuilder.class);
+ when(builder.build()).thenReturn(mock(DaprClient.class));
+ return builder;
+ }
+}
diff --git a/dapr-spring/dapr-spring-boot-autoconfigure/src/test/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprClientTest.java b/dapr-spring/dapr-spring-boot-autoconfigure/src/test/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprClientTest.java
new file mode 100644
index 0000000000..76d9bafd24
--- /dev/null
+++ b/dapr-spring/dapr-spring-boot-autoconfigure/src/test/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprClientTest.java
@@ -0,0 +1,367 @@
+/*
+ * Copyright 2025 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.spring.boot.autoconfigure.client;
+
+import io.dapr.client.DaprClient;
+import io.dapr.client.domain.DeleteStateRequest;
+import io.dapr.client.domain.GetSecretRequest;
+import io.dapr.client.domain.GetStateRequest;
+import io.dapr.client.domain.InvokeBindingRequest;
+import io.dapr.client.domain.PublishEventRequest;
+import io.dapr.client.domain.ScheduleJobRequest;
+import io.dapr.client.domain.State;
+import io.micrometer.observation.tck.TestObservationRegistry;
+import io.micrometer.observation.tck.TestObservationRegistryAssert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Unit tests for {@link ObservationDaprClient}.
+ *
+ *
+ *
+ */
+@ExtendWith(MockitoExtension.class)
+class ObservationDaprClientTest {
+
+ @Mock
+ private DaprClient delegate;
+
+ private TestObservationRegistry registry;
+ private ObservationDaprClient client;
+
+ @BeforeEach
+ void setUp() {
+ registry = TestObservationRegistry.create();
+ client = new ObservationDaprClient(delegate, registry);
+ }
+
+ // -------------------------------------------------------------------------
+ // Transparency — the wrapper IS-A DaprClient
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("ObservationDaprClient is assignable to DaprClient (transparent to consumers)")
+ void isAssignableToDaprClient() {
+ assertThat(client).isInstanceOf(DaprClient.class);
+ }
+
+ // -------------------------------------------------------------------------
+ // Pub/Sub
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("publishEvent(pubsubName, topicName, data) creates span dapr.client.publish_event")
+ void publishEventCreatesSpan() {
+ when(delegate.publishEvent("my-pubsub", "my-topic", "payload")).thenReturn(Mono.empty());
+
+ client.publishEvent("my-pubsub", "my-topic", "payload").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.publish_event")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.pubsub.name", "my-pubsub")
+ .hasHighCardinalityKeyValue("dapr.topic.name", "my-topic");
+ }
+
+ @Test
+ @DisplayName("publishEvent(PublishEventRequest) creates span dapr.client.publish_event")
+ void publishEventRequestCreatesSpan() {
+ PublishEventRequest request = new PublishEventRequest("my-pubsub", "my-topic", "payload");
+ when(delegate.publishEvent(request)).thenReturn(Mono.empty());
+
+ client.publishEvent(request).block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.publish_event");
+ }
+
+ @Test
+ @DisplayName("publishEvent span records error when delegate throws")
+ void publishEventRecordsError() {
+ RuntimeException boom = new RuntimeException("publish failed");
+ when(delegate.publishEvent("pubsub", "topic", "data")).thenReturn(Mono.error(boom));
+
+ assertThatThrownBy(() -> client.publishEvent("pubsub", "topic", "data").block())
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.publish_event")
+ .that()
+ .hasError();
+ }
+
+ // -------------------------------------------------------------------------
+ // Bindings
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("invokeBinding(name, operation, data) creates span dapr.client.invoke_binding")
+ void invokeBindingCreatesSpan() {
+ when(delegate.invokeBinding("my-binding", "create", "data")).thenReturn(Mono.empty());
+
+ client.invokeBinding("my-binding", "create", "data").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.invoke_binding")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.binding.name", "my-binding")
+ .hasHighCardinalityKeyValue("dapr.binding.operation", "create");
+ }
+
+ @Test
+ @DisplayName("invokeBinding(InvokeBindingRequest) creates span dapr.client.invoke_binding")
+ void invokeBindingRequestCreatesSpan() {
+ InvokeBindingRequest request = new InvokeBindingRequest("my-binding", "create");
+ when(delegate.invokeBinding(request)).thenReturn(Mono.empty());
+
+ client.invokeBinding(request).block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.invoke_binding");
+ }
+
+ // -------------------------------------------------------------------------
+ // State
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("getState(storeName, key, Class) creates span dapr.client.get_state")
+ void getStateCreatesSpan() {
+ when(delegate.getState("my-store", "my-key", String.class)).thenReturn(Mono.empty());
+
+ client.getState("my-store", "my-key", String.class).block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.get_state")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.store.name", "my-store")
+ .hasHighCardinalityKeyValue("dapr.state.key", "my-key");
+ }
+
+ @Test
+ @DisplayName("saveState creates span dapr.client.save_state")
+ void saveStateCreatesSpan() {
+ when(delegate.saveState("my-store", "my-key", "value")).thenReturn(Mono.empty());
+
+ client.saveState("my-store", "my-key", "value").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.save_state")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.store.name", "my-store")
+ .hasHighCardinalityKeyValue("dapr.state.key", "my-key");
+ }
+
+ @Test
+ @DisplayName("deleteState creates span dapr.client.delete_state")
+ void deleteStateCreatesSpan() {
+ when(delegate.deleteState("my-store", "my-key")).thenReturn(Mono.empty());
+
+ client.deleteState("my-store", "my-key").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.delete_state")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.store.name", "my-store")
+ .hasHighCardinalityKeyValue("dapr.state.key", "my-key");
+ }
+
+ @Test
+ @DisplayName("getBulkState creates span dapr.client.get_bulk_state")
+ void getBulkStateCreatesSpan() {
+ when(delegate.getBulkState("my-store", List.of("k1", "k2"), String.class))
+ .thenReturn(Mono.empty());
+
+ client.getBulkState("my-store", List.of("k1", "k2"), String.class).block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.get_bulk_state");
+ }
+
+ @Test
+ @DisplayName("executeStateTransaction creates span dapr.client.execute_state_transaction")
+ void executeStateTransactionCreatesSpan() {
+ when(delegate.executeStateTransaction("my-store", List.of())).thenReturn(Mono.empty());
+
+ client.executeStateTransaction("my-store", List.of()).block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.execute_state_transaction");
+ }
+
+ // -------------------------------------------------------------------------
+ // Secrets
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("getSecret(storeName, secretName) creates span dapr.client.get_secret")
+ void getSecretCreatesSpan() {
+ when(delegate.getSecret("my-vault", "db-password")).thenReturn(Mono.empty());
+
+ client.getSecret("my-vault", "db-password").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.get_secret")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.secret.store", "my-vault")
+ .hasHighCardinalityKeyValue("dapr.secret.name", "db-password");
+ }
+
+ @Test
+ @DisplayName("getBulkSecret creates span dapr.client.get_bulk_secret")
+ void getBulkSecretCreatesSpan() {
+ when(delegate.getBulkSecret("my-vault")).thenReturn(Mono.empty());
+
+ client.getBulkSecret("my-vault").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.get_bulk_secret");
+ }
+
+ // -------------------------------------------------------------------------
+ // Configuration
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("getConfiguration creates span dapr.client.get_configuration")
+ void getConfigurationCreatesSpan() {
+ when(delegate.getConfiguration("my-config-store", "feature-flag")).thenReturn(Mono.empty());
+
+ client.getConfiguration("my-config-store", "feature-flag").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.get_configuration")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.configuration.store", "my-config-store");
+ }
+
+ @Test
+ @DisplayName("subscribeConfiguration creates span dapr.client.subscribe_configuration")
+ void subscribeConfigurationCreatesSpan() {
+ when(delegate.subscribeConfiguration("my-store", "k1")).thenReturn(Flux.empty());
+
+ client.subscribeConfiguration("my-store", "k1").blockLast();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.subscribe_configuration");
+ }
+
+ @Test
+ @DisplayName("unsubscribeConfiguration creates span dapr.client.unsubscribe_configuration")
+ void unsubscribeConfigurationCreatesSpan() {
+ when(delegate.unsubscribeConfiguration("sub-id", "my-store")).thenReturn(Mono.empty());
+
+ client.unsubscribeConfiguration("sub-id", "my-store").block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.unsubscribe_configuration");
+ }
+
+ // -------------------------------------------------------------------------
+ // Metadata & Lifecycle
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("getMetadata creates span dapr.client.get_metadata")
+ void getMetadataCreatesSpan() {
+ when(delegate.getMetadata()).thenReturn(Mono.empty());
+
+ client.getMetadata().block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.get_metadata");
+ }
+
+ @Test
+ @DisplayName("waitForSidecar creates span dapr.client.wait_for_sidecar")
+ void waitForSidecarCreatesSpan() {
+ when(delegate.waitForSidecar(5000)).thenReturn(Mono.empty());
+
+ client.waitForSidecar(5000).block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.wait_for_sidecar");
+ }
+
+ @Test
+ @DisplayName("shutdown creates span dapr.client.shutdown")
+ void shutdownCreatesSpan() {
+ when(delegate.shutdown()).thenReturn(Mono.empty());
+
+ client.shutdown().block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.shutdown");
+ }
+
+ // -------------------------------------------------------------------------
+ // Jobs
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("scheduleJob creates span dapr.client.schedule_job")
+ void scheduleJobCreatesSpan() {
+ ScheduleJobRequest request = new ScheduleJobRequest("nightly-cleanup",
+ io.dapr.client.domain.JobSchedule.daily());
+ when(delegate.scheduleJob(request)).thenReturn(Mono.empty());
+
+ client.scheduleJob(request).block();
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.client.schedule_job")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.job.name", "nightly-cleanup");
+ }
+
+ // -------------------------------------------------------------------------
+ // Deprecated methods — must NOT create spans
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("Deprecated invokeMethod delegates without creating a span")
+ @SuppressWarnings("deprecation")
+ void deprecatedInvokeMethodDoesNotCreateSpan() {
+ when(delegate.invokeMethod(anyString(), anyString(), nullable(Object.class),
+ any(io.dapr.client.domain.HttpExtension.class), any(Class.class)))
+ .thenReturn(Mono.empty());
+
+ client.invokeMethod("app", "method", (Object) null,
+ io.dapr.client.domain.HttpExtension.NONE, String.class).block();
+
+ // Registry must be empty — no spans for deprecated methods
+ TestObservationRegistryAssert.assertThat(registry).doesNotHaveAnyObservation();
+ }
+}
diff --git a/dapr-spring/dapr-spring-boot-autoconfigure/src/test/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprWorkflowClientTest.java b/dapr-spring/dapr-spring-boot-autoconfigure/src/test/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprWorkflowClientTest.java
new file mode 100644
index 0000000000..f60dd2cf5a
--- /dev/null
+++ b/dapr-spring/dapr-spring-boot-autoconfigure/src/test/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprWorkflowClientTest.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2025 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.spring.boot.autoconfigure.client;
+
+import io.dapr.config.Properties;
+import io.dapr.workflows.client.DaprWorkflowClient;
+import io.micrometer.observation.tck.TestObservationRegistry;
+import io.micrometer.observation.tck.TestObservationRegistryAssert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * Unit tests for {@link ObservationDaprWorkflowClient}.
+ *
+ *
+ *
+ */
+class ObservationDaprWorkflowClientTest {
+
+ private TestObservationRegistry registry;
+ private ObservationDaprWorkflowClient client;
+
+ @BeforeEach
+ void setUp() {
+ registry = TestObservationRegistry.create();
+ // Properties with no gRPC endpoint — channel created lazily, no sidecar needed
+ client = new ObservationDaprWorkflowClient(new Properties(), registry);
+ }
+
+ // -------------------------------------------------------------------------
+ // Transparency — the wrapper IS-A DaprWorkflowClient
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("ObservationDaprWorkflowClient is assignable to DaprWorkflowClient (transparent)")
+ void isAssignableToDaprWorkflowClient() {
+ assertThat(client).isInstanceOf(DaprWorkflowClient.class);
+ }
+
+ // -------------------------------------------------------------------------
+ // scheduleNewWorkflow — span is created even when the call fails (no sidecar)
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("scheduleNewWorkflow(String) creates span dapr.workflow.schedule")
+ void scheduleNewWorkflowByNameCreatesSpan() {
+ // The gRPC call will fail — but the span must be recorded with an error
+ assertThatThrownBy(() -> client.scheduleNewWorkflow("MyWorkflow"))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.schedule")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.name", "MyWorkflow")
+ .hasError();
+ }
+
+ @Test
+ @DisplayName("scheduleNewWorkflow(Class) delegates to String overload — span is still created")
+ void scheduleNewWorkflowByClassDelegatesToStringOverload() {
+ // The Class-based overload in the parent calls this.scheduleNewWorkflow(canonicalName),
+ // which resolves to our overridden String-based method — the span is created naturally.
+ assertThatThrownBy(() -> client.scheduleNewWorkflow(DummyWorkflow.class))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.schedule")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.name", DummyWorkflow.class.getCanonicalName())
+ .hasError();
+ }
+
+ @Test
+ @DisplayName("scheduleNewWorkflow(String, Object, String) includes instance_id in span")
+ void scheduleNewWorkflowWithInstanceIdCreatesSpan() {
+ assertThatThrownBy(() -> client.scheduleNewWorkflow("MyWorkflow", null, "my-instance-123"))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.schedule")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.instance_id", "my-instance-123")
+ .hasError();
+ }
+
+ // -------------------------------------------------------------------------
+ // Lifecycle operations
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("suspendWorkflow creates span dapr.workflow.suspend")
+ void suspendWorkflowCreatesSpan() {
+ assertThatThrownBy(() -> client.suspendWorkflow("instance-1", "pausing"))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.suspend")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.instance_id", "instance-1")
+ .hasError();
+ }
+
+ @Test
+ @DisplayName("resumeWorkflow creates span dapr.workflow.resume")
+ void resumeWorkflowCreatesSpan() {
+ assertThatThrownBy(() -> client.resumeWorkflow("instance-1", "resuming"))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.resume")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.instance_id", "instance-1")
+ .hasError();
+ }
+
+ @Test
+ @DisplayName("terminateWorkflow creates span dapr.workflow.terminate")
+ void terminateWorkflowCreatesSpan() {
+ assertThatThrownBy(() -> client.terminateWorkflow("instance-1", null))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.terminate")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.instance_id", "instance-1")
+ .hasError();
+ }
+
+ // -------------------------------------------------------------------------
+ // State queries
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("getWorkflowState creates span dapr.workflow.get_state")
+ void getWorkflowStateCreatesSpan() {
+ assertThatThrownBy(() -> client.getWorkflowState("instance-1", false))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.get_state")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.instance_id", "instance-1")
+ .hasError();
+ }
+
+ // -------------------------------------------------------------------------
+ // Events
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("raiseEvent creates span dapr.workflow.raise_event")
+ void raiseEventCreatesSpan() {
+ assertThatThrownBy(() -> client.raiseEvent("instance-1", "OrderPlaced", "payload"))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.raise_event")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.instance_id", "instance-1")
+ .hasHighCardinalityKeyValue("dapr.workflow.event_name", "OrderPlaced")
+ .hasError();
+ }
+
+ // -------------------------------------------------------------------------
+ // Cleanup
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("purgeWorkflow creates span dapr.workflow.purge")
+ void purgeWorkflowCreatesSpan() {
+ assertThatThrownBy(() -> client.purgeWorkflow("instance-1"))
+ .isInstanceOf(RuntimeException.class);
+
+ TestObservationRegistryAssert.assertThat(registry)
+ .hasObservationWithNameEqualTo("dapr.workflow.purge")
+ .that()
+ .hasHighCardinalityKeyValue("dapr.workflow.instance_id", "instance-1")
+ .hasError();
+ }
+
+ // -------------------------------------------------------------------------
+ // Deprecated methods — must NOT create spans
+ // -------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("Deprecated getInstanceState falls through to parent without creating a span")
+ @SuppressWarnings("deprecation")
+ void deprecatedGetInstanceStateDoesNotCreateSpan() {
+ // This will fail (no sidecar) but must not leave any observations in the registry
+ assertThatThrownBy(() -> client.getInstanceState("instance-1", false))
+ .isInstanceOf(RuntimeException.class);
+
+ // No spans should have been created for deprecated methods
+ TestObservationRegistryAssert.assertThat(registry).doesNotHaveAnyObservation();
+ }
+
+ // -------------------------------------------------------------------------
+ // Dummy workflow implementation for type-based tests
+ // -------------------------------------------------------------------------
+
+ static class DummyWorkflow implements io.dapr.workflows.Workflow {
+ @Override
+ public io.dapr.workflows.WorkflowStub create() {
+ return ctx -> {
+ };
+ }
+ }
+}