wip - support for DT in LV

Author: solnic

lib/sentry.ex

@@ -14,7 +14,8 @@ defmodule Sentry do
 
     * Automatically for Plug/Phoenix applications — see the
       [*Setup with Plug and Phoenix* guide](setup-with-plug-and-phoenix.html), and the
-      `Sentry.PlugCapture` and `Sentry.PlugContext` modules.
+      `Sentry.PlugCapture`, `Sentry.PlugContext`, `Sentry.Plug.LiveViewContext`, and
+      `Sentry.Phoenix.LiveViewTracing`.
 
     * Through integrations for various ecosystem tools, like [Oban](oban-integration.html)
       or [Quantum](quantum-integration.html).

lib/sentry/opentelemetry/span_processor.ex

@@ -31,10 +31,16 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
       # HTTP server request spans should be treated as transaction roots even when they have
       # an external parent span ID (from distributed tracing)
       is_transaction_root =
-        span_record.parent_span_id == nil or is_http_server_request_span?(span_record)
+        span_record.parent_span_id == nil or
+          is_http_server_request_span?(span_record) or
+          is_live_view_server_span?(span_record)
 
       if is_transaction_root do
-        child_span_records = SpanStorage.get_child_spans(span_record.span_id)
+        child_span_records =
+          span_record.span_id
+          |> SpanStorage.get_child_spans()
+          |> maybe_add_remote_children(span_record)
+
         transaction = build_transaction(span_record, child_span_records)
 
         result =
@@ -83,6 +89,68 @@ if Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
         Map.has_key?(attributes, to_string(HTTPAttributes.http_request_method()))
     end
 
+    defp is_live_view_server_span?(%{kind: :server, origin: origin, name: name})
+         when origin in ["opentelemetry_phoenix", :opentelemetry_phoenix] do
+      String.ends_with?(name, ".mount") or
+        String.contains?(name, ".handle_params") or
+        String.contains?(name, ".handle_event")
+    end
+
+    defp is_live_view_server_span?(_span_record), do: false
+
+    defp maybe_add_remote_children(child_span_records, %{parent_span_id: nil}) do
+      child_span_records
+    end
+
+    defp maybe_add_remote_children(child_span_records, span_record) do
+      if is_live_view_server_span?(span_record) do
+        existing_ids = MapSet.new(child_span_records, & &1.span_id)
+
+        adopted_children =
+          span_record.parent_span_id
+          |> SpanStorage.get_child_spans()
+          |> Enum.filter(&eligible_for_adoption?(&1, span_record, existing_ids))
+          |> Enum.map(&%{&1 | parent_span_id: span_record.span_id})
+
+        Enum.each(adopted_children, fn child ->
+          :ok = SpanStorage.remove_child_span(span_record.parent_span_id, child.span_id)
+        end)
+
+        child_span_records ++ adopted_children
+      else
+        child_span_records
+      end
+    end
+
+    defp eligible_for_adoption?(child, span_record, existing_ids) do
+      not MapSet.member?(existing_ids, child.span_id) and
+        child.parent_span_id == span_record.parent_span_id and
+        child.trace_id == span_record.trace_id and
+        child.kind != :server and
+        occurs_within_span?(child, span_record)
+    end
+
+    defp occurs_within_span?(child, parent) do
+      with {:ok, parent_start} <- parse_datetime(parent.start_time),
+           {:ok, parent_end} <- parse_datetime(parent.end_time),
+           {:ok, child_start} <- parse_datetime(child.start_time),
+           {:ok, child_end} <- parse_datetime(child.end_time) do
+        DateTime.compare(child_start, parent_start) != :lt and
+          DateTime.compare(child_end, parent_end) != :gt
+      else
+        _ -> true
+      end
+    end
+
+    defp parse_datetime(nil), do: :error
+
+    defp parse_datetime(timestamp) do
+      case DateTime.from_iso8601(timestamp) do
+        {:ok, datetime, _offset} -> {:ok, datetime}
+        {:error, _} -> :error
+      end
+    end
+
     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))

lib/sentry/phoenix/live_view_tracing.ex

@@ -0,0 +1,67 @@
+if Code.ensure_loaded?(Phoenix.LiveView) and
+     Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
+  defmodule Sentry.Phoenix.LiveViewTracing do
+    @moduledoc """
+    LiveView hook that attaches the propagated OpenTelemetry context saved by `Sentry.Plug.LiveViewContext`.
+
+    Configure your router with `on_mount {Sentry.Phoenix.LiveViewTracing, :attach}` so that the LiveView
+    process can deserialize the carrier written to the session, attach it to the process, and inherit the
+    incoming trace ID for spans emitted by `opentelemetry_phoenix`.
+
+    If the session key is missing (for example, when a LiveView spawns another LiveView), the hook falls
+    back to `OpentelemetryProcessPropagator.fetch_parent_ctx/0` when the dependency is available.
+    """
+
+    alias OpenTelemetry.Ctx
+    alias Sentry.OpenTelemetry.Propagator
+
+    @session_key "__sentry_live_view_context__"
+    @context_token_key :sentry_live_view_tracing_token
+
+    @doc """
+    Attach the propagated context to a LiveView process.
+    """
+    @spec on_mount(atom(), map(), map(), Phoenix.LiveView.Socket.t()) ::
+            {:cont, Phoenix.LiveView.Socket.t()}
+    def on_mount(:attach, _params, session, socket) do
+      {:cont, maybe_attach_context(socket, session)}
+    end
+
+    defp maybe_attach_context(socket, session) do
+      case Map.get(session, @session_key) do
+        carrier when is_map(carrier) and carrier != %{} ->
+          attach_context(socket, extract_context(carrier))
+
+        _ ->
+          attach_context(socket, fetch_parent_context())
+      end
+    end
+
+    defp extract_context(carrier) do
+      ctx = Ctx.get_current()
+      keys_fun = fn _ -> Map.keys(carrier) end
+      getter = fn key, _ -> Map.get(carrier, key, :undefined) end
+
+      Propagator.extract(ctx, carrier, keys_fun, getter, [])
+    end
+
+    defp fetch_parent_context do
+      module = :OpentelemetryProcessPropagator
+
+      if Code.ensure_loaded?(module) do
+        apply(module, :fetch_parent_ctx, [])
+      else
+        :undefined
+      end
+    end
+
+    defp attach_context(socket, ctx) when ctx in [:undefined, nil] do
+      socket
+    end
+
+    defp attach_context(socket, ctx) do
+      token = Ctx.attach(ctx)
+      %{socket | private: Map.put(socket.private, @context_token_key, token)}
+    end
+  end
+end

lib/sentry/plug/live_view_context.ex

@@ -0,0 +1,119 @@
+if Code.ensure_loaded?(Plug) and Sentry.OpenTelemetry.VersionChecker.tracing_compatible?() do
+  defmodule Sentry.Plug.LiveViewContext do
+    @moduledoc """
+    Plug that captures the current OpenTelemetry context and embeds it into the LiveView session.
+
+    When placed before your LiveView routes, it serializes the currently attached trace (`sentry-trace`
+    and `baggage`) via `Sentry.OpenTelemetry.Propagator`. The serialized carrier is stored under
+    `"__sentry_live_view_context__"` in the session so the LiveView process can pick it up, and a
+    companion cleanup plug removes the key after the response has been committed.
+    """
+
+    @behaviour Plug
+
+    alias OpenTelemetry.Ctx
+    alias OpenTelemetry.Tracer
+    alias Sentry.OpenTelemetry.Propagator
+
+    @session_key "__sentry_live_view_context__"
+    @sentry_trace_header "sentry-trace"
+    @ctx_token_key :sentry_live_view_ctx_token
+
+    @impl Plug
+    def init(opts), do: opts
+
+    @impl Plug
+    def call(conn, _opts) do
+      {conn, carrier} = ensure_trace_carrier(conn)
+      store_session(conn, carrier)
+    end
+
+    defp store_session(conn, carrier) do
+      if Map.has_key?(carrier, @sentry_trace_header) do
+        conn
+        |> Plug.Conn.fetch_session()
+        |> Plug.Conn.put_session(@session_key, carrier)
+      else
+        conn
+      end
+    end
+
+    defp ensure_trace_carrier(conn) do
+      ctx_carrier = build_carrier_from_ctx()
+
+      if Map.has_key?(ctx_carrier, @sentry_trace_header) do
+        {conn, ctx_carrier}
+      else
+        header_carrier = build_carrier_from_headers(conn)
+
+        if Map.has_key?(header_carrier, @sentry_trace_header) do
+          attach_conn = attach_from_headers(conn, header_carrier)
+          {attach_conn, header_carrier}
+        else
+          {conn, header_carrier}
+        end
+      end
+    end
+
+    defp build_carrier_from_ctx do
+      ctx = Ctx.get_current()
+      setter = fn key, value, acc -> Map.put(acc, key, value) end
+      Propagator.inject(ctx, %{}, setter, [])
+    end
+
+    defp build_carrier_from_headers(conn) do
+      Enum.reduce([@sentry_trace_header, "baggage"], %{}, fn header, acc ->
+        case Plug.Conn.get_req_header(conn, header) do
+          [value | _] -> Map.put(acc, header, value)
+          _ -> acc
+        end
+      end)
+    end
+
+    defp attach_from_headers(conn, carrier) do
+      ctx = maybe_extract(carrier)
+
+      case ctx do
+        nil ->
+          conn
+
+        _ ->
+          span_ctx = Tracer.current_span_ctx(ctx)
+
+          if span_ctx == :undefined do
+            conn
+          else
+            token = Ctx.attach(ctx)
+            register_detach(conn, token)
+          end
+      end
+    end
+
+    defp maybe_extract(carrier) do
+      ctx = Ctx.get_current()
+      getter = fn key, _ -> Map.get(carrier, key, :undefined) end
+      Propagator.extract(ctx, carrier, fn _ -> Map.keys(carrier) end, getter, [])
+    rescue
+      _ -> nil
+    end
+
+    defp register_detach(conn, token) do
+      conn
+      |> Plug.Conn.put_private(@ctx_token_key, token)
+      |> Plug.Conn.register_before_send(fn conn ->
+        _ =
+          case conn.private[@ctx_token_key] do
+            nil -> :ok
+            token -> Ctx.detach(token)
+          end
+
+        conn
+      end)
+    end
+
+    @doc false
+    def delete_session_key(conn) do
+      Plug.Conn.delete_session(conn, @session_key)
+    end
+  end
+end

lib/sentry/plug/live_view_context_cleanup.ex

@@ -0,0 +1,17 @@
+if Code.ensure_loaded?(Plug) do
+  defmodule Sentry.Plug.LiveViewContextCleanup do
+    @moduledoc false
+
+    @behaviour Plug
+
+    alias Sentry.Plug.LiveViewContext
+
+    @impl Plug
+    def init(opts), do: opts
+
+    @impl Plug
+    def call(conn, _opts) do
+      Plug.Conn.register_before_send(conn, &LiveViewContext.delete_session_key/1)
+    end
+  end
+end

mix.exs

@@ -50,7 +50,13 @@ defmodule Sentry.Mixfile do
           "Upgrade Guides": [~r{^pages/upgrade}]
         ],
         groups_for_modules: [
-          "Plug and Phoenix": [Sentry.PlugCapture, Sentry.PlugContext, Sentry.LiveViewHook],
+          "Plug and Phoenix": [
+            Sentry.PlugCapture,
+            Sentry.PlugContext,
+            Sentry.Plug.LiveViewContext,
+            Sentry.LiveViewHook,
+            Sentry.Phoenix.LiveViewTracing
+          ],
           Loggers: [Sentry.LoggerBackend, Sentry.LoggerHandler],
           "Data Structures": [Sentry.Attachment, Sentry.CheckIn, Sentry.ClientReport],
           HTTP: [Sentry.HTTPClient, Sentry.HackneyClient],