wip - integrate LiveView detection into SpanProcessor

Author: solnic

lib/sentry/opentelemetry/span_processor.ex

@@ -22,6 +22,14 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
 
     @impl :otel_span_processor
     def on_start(_ctx, otel_span, _config) do
+      # Check if this is a LiveView span during static render
+      # If so, mark it so we can filter it out in on_end
+      if liveview_propagator_loaded?() and
+           Sentry.OpenTelemetry.LiveViewPropagator.static_render?() do
+        # Set an attribute on the span to mark it as from static render
+        :otel_span.set_attribute(otel_span, :"sentry.liveview.static_render", true)
+      end
+
       # Track pending children: when a span starts with a parent, register it
       # as a pending child. This allows us to wait for all children when
       # the parent ends, solving the race condition where parent.on_end
@@ -44,7 +52,21 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
     @impl :otel_span_processor
     def on_end(otel_span, _config) do
       span_record = SpanRecord.new(otel_span)
-      process_span(span_record)
+
+      # Skip LiveView spans from static render - they're redundant since:
+      # 1. The HTTP span already covers the static render phase
+      # 2. The same LiveView callbacks run again over WebSocket (the meaningful ones)
+      if static_render_liveview_span?(span_record) do
+        # Don't store or process this span
+        # But still remove from pending children if it was tracked
+        if span_record.parent_span_id != nil do
+          SpanStorage.remove_pending_child(span_record.parent_span_id, span_record.span_id)
+        end
+
+        true
+      else
+        process_span(span_record)
+      end
     end
 
     defp process_span(span_record) do
@@ -70,6 +92,10 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
       #
       # A span should NOT be a transaction root if:
       # - It has a LOCAL parent (parent span exists in our SpanStorage)
+      #
+      # This prevents LiveView spans from becoming separate transactions when
+      # they occur within an HTTP request - they should be child spans of the
+      # HTTP server span instead.
       is_transaction_root =
         cond do
           # No parent = definitely a root
@@ -142,6 +168,9 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
         end
 
       # Clean up: remove the transaction root span and all its children
+      # Note: For distributed tracing, the transaction root span may have been stored
+      # as a child span (with a remote parent_span_id). In that case, we need to also
+      # remove it from the child spans, not just look for it as a root span.
       :ok = SpanStorage.remove_root_span(span_record.span_id)
 
       # Also clean up any remaining pending children records (shouldn't be any, but be safe)
@@ -156,6 +185,17 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
       result
     end
 
+    # Check if this is a LiveView span from static render that should be filtered out
+    defp static_render_liveview_span?(span_record) do
+      # Check for the attribute we set in on_start
+      Map.get(span_record.attributes, :"sentry.liveview.static_render", false) == true
+    end
+
+    # Check if the LiveViewPropagator module is loaded (only compiled when Phoenix.LiveView is available)
+    defp liveview_propagator_loaded? do
+      Code.ensure_loaded?(Sentry.OpenTelemetry.LiveViewPropagator)
+    end
+
     @impl :otel_span_processor
     def force_flush(_config) do
       :ok
@@ -170,11 +210,18 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
     end
 
     # Helper function to detect if a span is a server span that should be
-    # treated as a transaction root for distributed tracing.
-    # This includes HTTP server request spans (have http.request.method attribute)
-    defp is_server_span?(%{kind: :server, attributes: attributes}) do
+    # treated as a transaction root. This includes:
+    # - HTTP server request spans (have http.request.method attribute)
+    # - LiveView spans from OpentelemetryPhoenix (have kind: :server and origin: "opentelemetry_phoenix")
+    # But NOT internal spans created with Tracer.with_span (which have kind: :internal)
+    defp is_server_span?(%{kind: :server, attributes: attributes} = span_record) do
       # Check if it's an HTTP server request span (has http.request.method)
-      Map.has_key?(attributes, to_string(HTTPAttributes.http_request_method()))
+      has_http_method = Map.has_key?(attributes, to_string(HTTPAttributes.http_request_method()))
+
+      # Check if it's a LiveView span from OpentelemetryPhoenix
+      is_liveview_span = span_record.origin == "opentelemetry_phoenix"
+
+      has_http_method or is_liveview_span
     end
 
     defp is_server_span?(_), do: false

test_integrations/phoenix_app/lib/phoenix_app/application.ex

@@ -14,6 +14,11 @@ defmodule PhoenixApp.Application do
     })
 
     OpentelemetryBandit.setup()
+
+    # Set up Sentry's LiveView context propagation BEFORE OpentelemetryPhoenix
+    # This enables distributed tracing context to flow from HTTP requests to LiveView WebSocket processes
+    Sentry.OpenTelemetry.LiveViewPropagator.setup()
+
     OpentelemetryPhoenix.setup(adapter: :bandit)
     OpentelemetryOban.setup()
     OpentelemetryEcto.setup([:phoenix_app, :repo], db_statement: :enabled)

test_integrations/phoenix_app/lib/phoenix_app_web/router.ex

@@ -8,6 +8,7 @@ defmodule PhoenixAppWeb.Router do
     plug :put_root_layout, html: {PhoenixAppWeb.Layouts, :root}
     plug :protect_from_forgery
     plug :put_secure_browser_headers
+    plug Sentry.Plug.LiveViewContext
   end
 
   pipeline :api do