Support for Traces/Transactions via Opentelemetry

config/config.exs

@@ -15,4 +15,6 @@ if config_env() == :test do
   config :logger, backends: []
 end
 
+config :opentelemetry, span_processor: {Sentry.OpenTelemetry.SpanProcessor, []}
+
 config :phoenix, :json_library, Jason

lib/sentry.ex

@@ -362,6 +362,28 @@ defmodule Sentry do
     end
   end
 
+  def send_transaction(transaction, options \\ []) do
+    # TODO: remove on v11.0.0, :included_environments was deprecated in 10.0.0.
+    included_envs = Config.included_environments()
+
+    cond do
+      Config.test_mode?() ->
+        Client.send_transaction(transaction, options)
+
+      !Config.dsn() ->
+        # We still validate options even if we're not sending the event. This aims at catching
+        # configuration issues during development instead of only when deploying to production.
+        _options = NimbleOptions.validate!(options, Options.send_event_schema())
+        :ignored
+
+      included_envs == :all or to_string(Config.environment_name()) in included_envs ->
+        Client.send_transaction(transaction, options)
+
+      true ->
+        :ignored
+    end
+  end
+
   @doc """
   Captures a check-in built with the given `options`.
 

lib/sentry/application.ex

@@ -27,6 +27,7 @@ defmodule Sentry.Application do
         Sentry.Sources,
         Sentry.Dedupe,
         Sentry.ClientReport.Sender,
+        Sentry.OpenTelemetry.SpanStorage,
         {Sentry.Integrations.CheckInIDMappings,
          [
            max_expected_check_in_time:

lib/sentry/client.ex

@@ -16,7 +16,8 @@ defmodule Sentry.Client do
     Interfaces,
     LoggerUtils,
     Transport,
-    Options
+    Options,
+    Transaction
   }
 
   require Logger
@@ -107,6 +108,26 @@ defmodule Sentry.Client do
     |> Transport.encode_and_post_envelope(client, request_retries)
   end
 
+  def send_transaction(%Transaction{} = transaction, opts \\ []) do
+    # opts = validate_options!(opts)
+
+    result_type = Keyword.get_lazy(opts, :result, &Config.send_result/0)
+    client = Keyword.get_lazy(opts, :client, &Config.client/0)
+
+    request_retries =
+      Keyword.get_lazy(opts, :request_retries, fn ->
+        Application.get_env(:sentry, :request_retries, Transport.default_retries())
+      end)
+
+    case encode_and_send(transaction, result_type, client, request_retries) do
+      {:ok, id} ->
+        {:ok, id}
+
+      {:error, %ClientError{} = error} ->
+        {:error, error}
+    end
+  end
+
   defp sample_event(sample_rate) do
     cond do
       sample_rate == 1 -> :ok
@@ -205,6 +226,42 @@ defmodule Sentry.Client do
     end
   end
 
+  defp encode_and_send(
+         %Transaction{} = transaction,
+         _result_type = :sync,
+         client,
+         request_retries
+       ) do
+    case Sentry.Test.maybe_collect(transaction) do
+      :collected ->
+        {:ok, ""}
+
+      :not_collecting ->
+        send_result =
+          transaction
+          |> Envelope.from_transaction()
+          |> Transport.encode_and_post_envelope(client, request_retries)
+
+        send_result
+    end
+  end
+
+  defp encode_and_send(
+         %Transaction{} = transaction,
+         _result_type = :none,
+         client,
+         _request_retries
+       ) do
+    case Sentry.Test.maybe_collect(transaction) do
+      :collected ->
+        {:ok, ""}
+
+      :not_collecting ->
+        :ok = Transport.Sender.send_async(client, transaction)
+        {:ok, ""}
+    end
+  end
+
   @spec render_event(Event.t()) :: map()
   def render_event(%Event{} = event) do
     json_library = Config.json_library()
@@ -225,6 +282,19 @@ defmodule Sentry.Client do
     |> update_if_present(:threads, fn list -> Enum.map(list, &render_thread/1) end)
   end
 
+  @spec render_transaction(%Transaction{}) :: map()
+  def render_transaction(%Transaction{} = transaction) do
+    transaction
+    |> Transaction.to_map()
+    |> Map.merge(%{
+      platform: "elixir",
+      sdk: %{
+        name: "sentry.elixir",
+        version: "10.7.1"
+      }
+    })
+  end
+
   defp render_exception(%Interfaces.Exception{} = exception) do
     exception
     |> Map.from_struct()

lib/sentry/envelope.ex

@@ -2,11 +2,13 @@ defmodule Sentry.Envelope do
   @moduledoc false
   # https://develop.sentry.dev/sdk/envelopes/
 
-  alias Sentry.{Attachment, CheckIn, ClientReport, Config, Event, UUID}
+  alias Sentry.{Attachment, CheckIn, ClientReport, Config, Event, UUID, Transaction}
 
   @type t() :: %__MODULE__{
           event_id: UUID.t(),
-          items: [Event.t() | Attachment.t() | CheckIn.t() | ClientReport.t(), ...]
+          items: [
+            Event.t() | Attachment.t() | CheckIn.t() | ClientReport.t() | Transaction.t()
+          ]
         }
 
   @enforce_keys [:event_id, :items]
@@ -46,16 +48,35 @@ defmodule Sentry.Envelope do
     }
   end
 
+  @doc """
+  Creates a new envelope containing a transaction with spans.
+  """
+  @spec from_transaction(Sentry.Transaction.t()) :: t()
+  def from_transaction(%Transaction{} = transaction) do
+    %__MODULE__{
+      event_id: transaction.event_id,
+      items: [transaction]
+    }
+  end
+
   @doc """
   Returns the "data category" of the envelope's contents (to be used in client reports and more).
   """
   @doc since: "10.8.0"
-  @spec get_data_category(Attachment.t() | CheckIn.t() | ClientReport.t() | Event.t()) ::
+  @spec get_data_category(
+          Attachment.t()
+          | CheckIn.t()
+          | ClientReport.t()
+          | Event.t()
+          | Transaction.t()
+        ) ::
           String.t()
   def get_data_category(%Attachment{}), do: "attachment"
   def get_data_category(%CheckIn{}), do: "monitor"
   def get_data_category(%ClientReport{}), do: "internal"
   def get_data_category(%Event{}), do: "error"
+  # TODO: is this correct?
+  def get_data_category(%Transaction{}), do: "error"
 
   @doc """
   Encodes the envelope into its binary representation.
@@ -126,4 +147,15 @@ defmodule Sentry.Envelope do
         throw(error)
     end
   end
+
+  defp item_to_binary(json_library, %Transaction{} = transaction) do
+    case transaction |> Sentry.Client.render_transaction() |> json_library.encode() do
+      {:ok, encoded_transaction} ->
+        header = ~s({"type": "transaction", "length": #{byte_size(encoded_transaction)}})
+        [header, ?\n, encoded_transaction, ?\n]
+
+      {:error, _reason} = error ->
+        throw(error)
+    end
+  end
 end