Add auto-instrumentation for Spring MVC handler and @Transactional spans (like Datadog agent) #4617
Description
Is your feature request related to a problem? Please describe.
When using the Application Insights Java agent (3.7.x) with a Spring Boot application, the transaction waterfall only shows auto-instrumented external calls (JDBC, HTTP clients) but not the internal Spring
framework flow.
The Datadog Java agent, by comparison, automatically creates spans for Spring framework integration points via bytecode instrumentation, producing a detailed waterfall without any code change:
servlet.request (incoming HTTP)
└─ spring.handler (controller method)
└─ spring.transaction (@transactional service method)
└─ jdbc.query (SQL query via repository)
└─ postgresql.query (driver-level execution)
This is achieved because the Datadog agent instruments Spring MVC handler dispatch and Spring @transactional boundaries automatically — not every bean method, but the key framework integration points that
give full visibility into the request lifecycle.
With the Application Insights agent, the same request only shows:
GET /api/v1/threads/{id}/messages (request)
└─ SELECT ... FROM message (JDBC)
└─ POST https://openai.azure.com (HTTP)
The entire controller-to-service layer is invisible, making it difficult to identify which business logic step is slow or failing.
Describe the solution you would like
Auto-instrument Spring framework integration points that the Datadog agent already covers, specifically:
- spring.handler — Spring MVC handler method dispatch (the controller method matched by @RequestMapping / @GetMapping / etc.). This span should include the controller class and method name.
- spring.transaction — Spring @transactional boundaries. This would capture the service-layer method wrapped in a transaction, providing the controller → service link in the waterfall.
These are not arbitrary application methods — they are well-defined framework extension points where Spring already has interceptor/advice infrastructure. The agent could instrument HandlerAdapter.handle()
and TransactionInterceptor.invoke() at the bytecode level, just as it already does for JDBC and HTTP clients.
This would produce the same waterfall visibility that Datadog users get out of the box, without requiring any application code changes, @WithSpan annotations, or customInstrumentation configuration.
Describe alternatives you have considered
- customInstrumentation in applicationinsights.json: Requires listing every class and method individually. Does not scale, is fragile to maintain, and new methods are silently missed. No wildcard or pattern
support is available. - @WithSpan annotations: Requires modifying application code, adds a dependency on opentelemetry-instrumentation-annotations, and must be manually added to every relevant method.
- Spring AOP aspect with ObservationRegistry: A custom @aspect that wraps all Spring bean methods in Micrometer Observations (bridged to OTel spans via micrometer-tracing-bridge-otel). This works but
requires application-side code, adds spring-boot-starter-aop as a dependency, and introduces AOP proxy overhead. It also instruments more than necessary (every public bean method) since there is no way to
target just framework integration points. - OpenTelemetry Java agent extensions (ByteBuddy): Building a custom InstrumentationModule targeting Spring MVC and Spring TX. However, the Application Insights documentation does not guarantee compatibility
with custom agent extensions.
Additional context
The Datadog Java agent achieves this by instrumenting specific Spring framework classes at the bytecode level:
- HandlerAdapter / DispatcherServlet for spring.handler spans
- PlatformTransactionManager / TransactionInterceptor for spring.transaction spans
These are stable Spring APIs that rarely change between versions. The OpenTelemetry upstream agent already instruments Spring MVC handlers (via spring-webmvc instrumentation module), so the foundation exists
in the OTel ecosystem — it may just need to be enabled or surfaced in the Application Insights distribution.