chore(tests): add e2e tests for tracing

Author: solnic

test_integrations/phoenix_app/config/config.exs

@@ -65,6 +65,14 @@ config :opentelemetry, span_processor: {Sentry.OpenTelemetry.SpanProcessor, []}
 config :opentelemetry,
   sampler: {Sentry.OpenTelemetry.Sampler, [drop: ["Elixir.Oban.Stager process"]]}
 
+# Configure OpenTelemetry to use Sentry propagator for distributed tracing
+config :opentelemetry,
+  text_map_propagators: [
+    :trace_context,
+    :baggage,
+    Sentry.OpenTelemetry.Propagator
+  ]
+
 # Import environment specific config. This must remain at the bottom
 # of this file so it overrides the configuration defined above.
 import_config "#{config_env()}.exs"

test_integrations/phoenix_app/lib/phoenix_app_web/controllers/page_controller.ex

@@ -48,4 +48,35 @@ defmodule PhoenixAppWeb.PageController do
 
     render(conn, :home, layout: false)
   end
+
+  # E2E tracing test endpoints
+
+  def api_error(_conn, _params) do
+    raise ArithmeticError, "bad argument in arithmetic expression"
+  end
+
+  def health(conn, _params) do
+    json(conn, %{status: "ok"})
+  end
+
+  def api_data(conn, _params) do
+    Tracer.with_span "fetch_data" do
+      users = Repo.all(User)
+
+      Tracer.with_span "process_data" do
+        user_count = length(users)
+
+        first_user = Repo.get(User, 1)
+
+        json(conn, %{
+          message: "Data fetched successfully",
+          data: %{
+            user_count: user_count,
+            first_user: if(first_user, do: first_user.name, else: nil),
+            timestamp: DateTime.utc_now() |> DateTime.to_iso8601()
+          }
+        })
+      end
+    end
+  end
 end

test_integrations/phoenix_app/lib/phoenix_app_web/endpoint.ex

@@ -44,6 +44,8 @@ defmodule PhoenixAppWeb.Endpoint do
   plug Plug.RequestId
   plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint]
 
+  plug :cors
+
   plug Plug.Parsers,
     parsers: [:urlencoded, :multipart, :json],
     pass: ["*/*"],
@@ -53,4 +55,22 @@ defmodule PhoenixAppWeb.Endpoint do
   plug Plug.Head
   plug Plug.Session, @session_options
   plug PhoenixAppWeb.Router
+
+  # CORS plug for e2e tests - allows the Svelte frontend to make
+  # cross-origin requests to the Phoenix backend
+  defp cors(conn, _opts) do
+    conn
+    |> put_resp_header("access-control-allow-origin", "*")
+    |> put_resp_header("access-control-allow-methods", "GET, POST, PUT, DELETE, OPTIONS")
+    |> put_resp_header("access-control-allow-headers", "content-type, sentry-trace, baggage")
+    |> handle_preflight()
+  end
+
+  defp handle_preflight(%{method: "OPTIONS"} = conn) do
+    conn
+    |> send_resp(200, "")
+    |> halt()
+  end
+
+  defp handle_preflight(conn), do: conn
 end

test_integrations/phoenix_app/lib/phoenix_app_web/router.ex

@@ -12,6 +12,14 @@ defmodule PhoenixAppWeb.Router do
 
   pipeline :api do
     plug :accepts, ["json"]
+    plug :put_cors_headers
+  end
+
+  defp put_cors_headers(conn, _opts) do
+    conn
+    |> put_resp_header("access-control-allow-origin", "*")
+    |> put_resp_header("access-control-allow-methods", "GET, POST, PUT, DELETE, OPTIONS")
+    |> put_resp_header("access-control-allow-headers", "content-type, authorization, sentry-trace, baggage")
   end
 
   scope "/", PhoenixAppWeb do
@@ -32,6 +40,15 @@ defmodule PhoenixAppWeb.Router do
     live "/users/:id/show/edit", UserLive.Show, :edit
   end
 
+  # For e2e DT tests with a front-end app
+  scope "/", PhoenixAppWeb do
+    pipe_through :api
+
+    get "/error", PageController, :api_error
+    get "/health", PageController, :health
+    get "/api/data", PageController, :api_data
+  end
+
   # Other scopes may use custom stacks.
   # scope "/api", PhoenixAppWeb do
   #   pipe_through :api

test_integrations/tracing/tests/helpers.ts

@@ -0,0 +1,99 @@
+import fs from "fs";
+import path from "path";
+
+const DEBUG_LOG_PATH = path.join(
+  process.cwd(),
+  "..",
+  "phoenix_app",
+  "tmp",
+  "sentry_debug_events.log"
+);
+
+export interface SentryEvent {
+  type?: string;
+  transaction?: string;
+  exception?: Array<{
+    type: string;
+    value: string;
+  }>;
+  contexts?: {
+    trace?: {
+      trace_id?: string;
+      span_id?: string;
+      parent_span_id?: string;
+      op?: string;
+      data?: Record<string, any>;
+    };
+  };
+  _meta?: {
+    dsc?: {
+      sample_rand?: string;
+    };
+  };
+  request?: {
+    headers?: Record<string, string>;
+  };
+}
+
+export interface SentryEnvelope {
+  headers: {
+    trace?: {
+      trace_id?: string;
+      sample_rate?: string;
+      sample_rand?: string;
+      sampled?: string;
+      environment?: string;
+      public_key?: string;
+      [key: string]: any;
+    };
+  };
+  items: SentryEvent[];
+}
+
+export interface LoggedEvents {
+  events: SentryEvent[];
+  envelopes: SentryEnvelope[];
+  event_count: number;
+}
+
+export function getLoggedEvents(): LoggedEvents {
+  const events: SentryEvent[] = [];
+  const envelopes: SentryEnvelope[] = [];
+
+  if (!fs.existsSync(DEBUG_LOG_PATH)) {
+    return { events: [], envelopes: [], event_count: 0 };
+  }
+
+  const content = fs.readFileSync(DEBUG_LOG_PATH, "utf-8");
+  const lines = content
+    .trim()
+    .split("\n")
+    .filter((line) => line.trim());
+
+  for (const line of lines) {
+    try {
+      const data = JSON.parse(line);
+
+      // Check if it's an envelope format
+      if (data.headers) {
+        envelopes.push(data as SentryEnvelope);
+        if (data.items) {
+          events.push(...data.items);
+        }
+      } else {
+        // Individual event
+        events.push(data as SentryEvent);
+      }
+    } catch (e) {
+      // Skip malformed lines
+    }
+  }
+
+  return { events, envelopes, event_count: events.length };
+}
+
+export function clearLoggedEvents(): void {
+  if (fs.existsSync(DEBUG_LOG_PATH)) {
+    fs.writeFileSync(DEBUG_LOG_PATH, "");
+  }
+}