wip - live view trace propagation

Author: solnic

lib/sentry/opentelemetry/live_view_propagator.ex

@@ -0,0 +1,209 @@
+if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() and
+     Code.ensure_loaded?(Phoenix.LiveView) do
+  defmodule Sentry.OpenTelemetry.LiveViewPropagator do
+    @moduledoc """
+    Telemetry handler that propagates OpenTelemetry context to LiveView processes.
+
+    This module attaches telemetry handlers for LiveView lifecycle events
+    (mount, handle_params, handle_event) that run BEFORE `opentelemetry_phoenix`
+    creates spans, ensuring the correct parent trace context is attached.
+
+    ## Why This Is Needed
+
+    When a browser makes an HTTP request with distributed tracing headers, the trace
+    context is correctly extracted for the initial request. However, Phoenix LiveView
+    spawns new BEAM processes for lifecycle callbacks.
+
+    `opentelemetry_phoenix` uses telemetry handlers to create spans for these events.
+    If we don't inject the parent context BEFORE those handlers run, each LiveView
+    span becomes a new root trace.
+
+    This module solves this by:
+    1. Attaching telemetry handlers with a lower priority (registered first)
+    2. Storing the trace context in process dictionary via `Sentry.Plug.LiveViewContext`
+    3. Extracting and attaching the context before `opentelemetry_phoenix` creates spans
+
+    ## Usage
+
+    Call `setup/0` in your application's start function, **BEFORE** calling
+    `OpentelemetryPhoenix.setup/1`:
+
+        def start(_type, _args) do
+          # Set up Sentry's LiveView context propagation FIRST
+          Sentry.OpenTelemetry.LiveViewPropagator.setup()
+
+          # Then set up OpentelemetryPhoenix
+          OpentelemetryPhoenix.setup(adapter: :bandit)
+
+          children = [
+            # ...
+          ]
+
+          Supervisor.start_link(children, strategy: :one_for_one)
+        end
+
+    Also add `Sentry.Plug.LiveViewContext` to your router pipeline:
+
+        pipeline :browser do
+          plug :accepts, ["html"]
+          plug :fetch_session
+          # ... other plugs
+          plug Sentry.Plug.LiveViewContext
+        end
+
+    *Available since v10.x.0.*
+    """
+
+    @moduledoc since: "10.8.0"
+
+    require Logger
+
+    @handler_id {__MODULE__, :live_view_context}
+
+    @doc """
+    Attaches telemetry handlers for LiveView context propagation.
+
+    Must be called BEFORE `OpentelemetryPhoenix.setup/1` to ensure handlers
+    run in the correct order.
+    """
+    @spec setup() :: :ok
+    def setup do
+      events = [
+        [:phoenix, :live_view, :mount, :start],
+        [:phoenix, :live_view, :handle_params, :start],
+        [:phoenix, :live_view, :handle_event, :start],
+        [:phoenix, :live_component, :handle_event, :start]
+      ]
+
+      :telemetry.attach_many(
+        @handler_id,
+        events,
+        &__MODULE__.handle_event/4,
+        %{}
+      )
+
+      :ok
+    end
+
+    @doc """
+    Detaches the telemetry handlers. Mainly useful for testing.
+    """
+    @spec teardown() :: :ok | {:error, :not_found}
+    def teardown do
+      :telemetry.detach(@handler_id)
+    end
+
+    @doc false
+    def handle_event(_event, _measurements, %{socket: socket} = _meta, _config) do
+      # During static render (HTTP request phase), we mark spans to be filtered
+      # since the HTTP span already covers this phase. Real LiveView interactions
+      # happen over WebSocket.
+      if static_render?(socket) do
+        # Store in process dict that this is a static render - the span processor
+        # can check this to filter out redundant LiveView spans
+        Process.put(:sentry_lv_static_render, true)
+        :ok
+      else
+        # WebSocket connection - clear the static render flag and propagate context
+        Process.delete(:sentry_lv_static_render)
+        propagate_context_if_needed(socket)
+      end
+    end
+
+    @doc """
+    Returns true if the current process is handling a static LiveView render.
+    Used by the span processor to filter redundant spans.
+    """
+    def static_render? do
+      Process.get(:sentry_lv_static_render, false)
+    end
+
+    # Check if this is a static render (not connected via WebSocket)
+    defp static_render?(socket) do
+      # During static render, transport_pid is nil
+      socket.transport_pid == nil
+    end
+
+    defp propagate_context_if_needed(socket) do
+      # Try to get trace context from socket's private assigns
+      case get_context_carrier(socket) do
+        nil ->
+          :ok
+
+        carrier when is_map(carrier) and map_size(carrier) > 0 ->
+          # Check if we already have an attached context with a valid span
+          # If so, don't overwrite it (this happens during static renders)
+          current_span_ctx = :otel_tracer.current_span_ctx()
+
+          unless has_valid_span?(current_span_ctx) do
+            # Extract and attach the trace context
+            ctx = :otel_ctx.get_current()
+
+            new_ctx =
+              Sentry.OpenTelemetry.Propagator.extract(
+                ctx,
+                carrier,
+                &map_keys/1,
+                &map_getter/2,
+                []
+              )
+
+            _old_ctx = :otel_ctx.attach(new_ctx)
+          end
+
+          :ok
+
+        _ ->
+          :ok
+      end
+    end
+
+    # Try to get the carrier from socket private assigns
+    defp get_context_carrier(socket) do
+      session_key = Sentry.Plug.LiveViewContext.session_key()
+
+      # The session can be in different places depending on the connection type:
+      # 1. WebSocket: socket.private.connect_info.session (map)
+      # 2. Static render (test): socket.private.connect_info is a %Plug.Conn{}
+      case socket do
+        # WebSocket connection has session as a map
+        %{private: %{connect_info: %{session: session}}} when is_map(session) ->
+          Map.get(session, session_key)
+
+        # Static render (Phoenix.LiveViewTest) has connect_info as Plug.Conn
+        %{private: %{connect_info: %Plug.Conn{private: %{plug_session: session}}}}
+        when is_map(session) ->
+          Map.get(session, session_key)
+
+        _ ->
+          nil
+      end
+    end
+
+    # Check if span context has a valid (non-zero) trace ID
+    defp has_valid_span?(:undefined), do: false
+
+    defp has_valid_span?(span_ctx) when is_tuple(span_ctx) do
+      case span_ctx do
+        {:span_ctx, trace_id, _span_id, _flags, _tracestate, _is_valid, _is_remote, _is_recording,
+         _sdk}
+        when trace_id != 0 ->
+          true
+
+        _ ->
+          false
+      end
+    end
+
+    defp has_valid_span?(_), do: false
+
+    defp map_keys(carrier), do: Map.keys(carrier)
+
+    defp map_getter(key, carrier) do
+      case Map.fetch(carrier, key) do
+        {:ok, value} -> value
+        :error -> :undefined
+      end
+    end
+  end
+end

lib/sentry/opentelemetry/span_processor.ex

@@ -18,20 +18,64 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
     # This can be a no-op since we can postpone inserting the span into storage until on_end
     @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 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
+
       otel_span
     end
 
     @impl :otel_span_processor
     def on_end(otel_span, _config) do
       span_record = SpanRecord.new(otel_span)
 
+      # 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
+        true
+      else
+        process_span(span_record)
+      end
+    end
+
+    defp process_span(span_record) do
       SpanStorage.store_span(span_record)
 
-      # Check if this is a root span (no parent) or a transaction root (HTTP server request span)
-      # HTTP server request spans should be treated as transaction roots even when they have
-      # an external parent span ID (from distributed tracing)
+      # Check if this is a root span (no parent) or a transaction root
+      #
+      # A span should be a transaction root if:
+      # 1. It has no parent (true root span)
+      # 2. OR it's a server span with only a REMOTE parent (distributed tracing)
+      #
+      # 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 =
-        span_record.parent_span_id == nil or is_http_server_request_span?(span_record)
+        cond do
+          # No parent = definitely a root
+          span_record.parent_span_id == nil ->
+            true
+
+          # Has a parent - check if it's local or remote
+          true ->
+            has_local_parent = has_local_parent_span?(span_record.parent_span_id)
+
+            if has_local_parent do
+              # Parent exists locally - this is a child span, not a transaction root
+              false
+            else
+              # Parent is remote (distributed tracing) - treat server spans as transaction roots
+              is_server_span?(span_record)
+            end
+        end
 
       if is_transaction_root do
         child_span_records = SpanStorage.get_child_spans(span_record.span_id)
@@ -71,18 +115,42 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
       end
     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
+
     @impl :otel_span_processor
     def force_flush(_config) do
       :ok
     end
 
-    # Helper function to detect if a span represents an HTTP server request
-    # that should be treated as a transaction root for distributed tracing
-    defp is_http_server_request_span?(%{kind: kind, attributes: attributes}) do
-      kind == :server and
-        Map.has_key?(attributes, to_string(HTTPAttributes.http_request_method()))
+    # Checks if a parent span exists in our local SpanStorage
+    # This helps distinguish between:
+    # - Local parents: span exists in storage (same service)
+    # - Remote parents: span doesn't exist in storage (distributed tracing from another service)
+    defp has_local_parent_span?(parent_span_id) do
+      SpanStorage.span_exists?(parent_span_id)
     end
 
+    # Helper function to detect if a span is a server span that should be
+    # 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)
+      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
+
     defp build_transaction(root_span_record, child_span_records) do
       root_span = build_span(root_span_record)
       child_spans = Enum.map(child_span_records, &build_span(&1))
@@ -135,12 +203,27 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
       client_address =
         Map.get(span_record.attributes, to_string(ClientAttributes.client_address()))
 
-      url_path = Map.get(span_record.attributes, to_string(URLAttributes.url_path()))
+      # Try multiple attributes for the URL path
+      url_path =
+        Map.get(span_record.attributes, to_string(URLAttributes.url_path())) ||
+          Map.get(span_record.attributes, "url.full") ||
+          Map.get(span_record.attributes, "http.target") ||
+          Map.get(span_record.attributes, "http.route") ||
+          span_record.name
 
+      # Build description with method and path
       description =
-        to_string(http_request_method) <>
-          ((client_address && " from #{client_address}") || "") <>
-          ((url_path && " #{url_path}") || "")
+        case url_path do
+          nil -> to_string(http_request_method)
+          path -> "#{http_request_method} #{path}"
+        end
+
+      description =
+        if client_address do
+          "#{description} from #{client_address}"
+        else
+          description
+        end
 
       {op, description}
     end

lib/sentry/opentelemetry/span_storage.ex

@@ -61,6 +61,25 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
       end
     end
 
+    @spec span_exists?(String.t(), keyword()) :: boolean()
+    def span_exists?(span_id, opts \\ []) do
+      table_name = Keyword.get(opts, :table_name, default_table_name())
+
+      # Check root spans first
+      case :ets.lookup(table_name, {:root_span, span_id}) do
+        [_] ->
+          true
+
+        [] ->
+          # Check child spans - scan for any child span with this span_id
+          # This is O(n) but necessary when the span has a remote parent
+          case :ets.match_object(table_name, {{:child_span, :_, span_id}, :_, :_}) do
+            [_ | _] -> true
+            [] -> false
+          end
+      end
+    end
+
     @spec get_child_spans(String.t(), keyword()) :: [SpanRecord.t()]
     def get_child_spans(parent_span_id, opts \\ []) do
       table_name = Keyword.get(opts, :table_name, default_table_name())