wip - Add Span and Transaction support

Author: solnic

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/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: Application.spec(:sentry, :vsn)
+      }
+    })
+  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,13 +48,31 @@ 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(%Transaction{}), do: "transaction"
   def get_data_category(%CheckIn{}), do: "monitor"
   def get_data_category(%ClientReport{}), do: "internal"
   def get_data_category(%Event{}), do: "error"
@@ -126,4 +146,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

lib/sentry/test.ex

@@ -78,6 +78,7 @@ defmodule Sentry.Test do
 
   @server __MODULE__.OwnershipServer
   @key :events
+  @transaction_key :transactions
 
   # Used internally when reporting an event, *before* reporting the actual event.
   @doc false
@@ -115,6 +116,48 @@ defmodule Sentry.Test do
     end
   end
 
+  # Used internally when reporting a transaction, *before* reporting the actual transaction.
+  @doc false
+  @spec maybe_collect(Sentry.Transaction.t()) :: :collected | :not_collecting
+  def maybe_collect(%Sentry.Transaction{} = transaction) do
+    if Sentry.Config.test_mode?() do
+      dsn_set? = not is_nil(Sentry.Config.dsn())
+      ensure_ownership_server_started()
+
+      case NimbleOwnership.fetch_owner(@server, callers(), @transaction_key) do
+        {:ok, owner_pid} ->
+          result =
+            NimbleOwnership.get_and_update(
+              @server,
+              owner_pid,
+              @transaction_key,
+              fn transactions ->
+                {:collected, (transactions || []) ++ [transaction]}
+              end
+            )
+
+          case result do
+            {:ok, :collected} ->
+              :collected
+
+            {:error, error} ->
+              raise ArgumentError,
+                    "cannot collect Sentry transactions: #{Exception.message(error)}"
+          end
+
+        :error when dsn_set? ->
+          :not_collecting
+
+        # If the :dsn option is not set and we didn't capture the transaction, it's alright,
+        # we can just swallow it.
+        :error ->
+          :collected
+      end
+    else
+      :not_collecting
+    end
+  end
+
   @doc """
   Starts collecting events from the current process.
 
@@ -135,7 +178,8 @@ defmodule Sentry.Test do
   @doc since: "10.2.0"
   @spec start_collecting_sentry_reports(map()) :: :ok
   def start_collecting_sentry_reports(_context \\ %{}) do
-    start_collecting()
+    start_collecting(key: @key)
+    start_collecting(key: @transaction_key)
   end
 
   @doc """
@@ -177,6 +221,7 @@ defmodule Sentry.Test do
   @doc since: "10.2.0"
   @spec start_collecting(keyword()) :: :ok
   def start_collecting(options \\ []) when is_list(options) do
+    key = Keyword.get(options, :key, @key)
     owner_pid = Keyword.get(options, :owner, self())
     cleanup? = Keyword.get(options, :cleanup, true)
 
@@ -190,7 +235,7 @@ defmodule Sentry.Test do
     # Make sure the ownership server is started (this is idempotent).
     ensure_ownership_server_started()
 
-    case NimbleOwnership.fetch_owner(@server, callers, @key) do
+    case NimbleOwnership.fetch_owner(@server, callers, key) do
       # No-op
       {tag, ^owner_pid} when tag in [:ok, :shared_owner] ->
         :ok
@@ -207,7 +252,7 @@ defmodule Sentry.Test do
     end
 
     {:ok, _} =
-      NimbleOwnership.get_and_update(@server, self(), @key, fn events ->
+      NimbleOwnership.get_and_update(@server, self(), key, fn events ->
         {:ignored, events || []}
       end)
 
@@ -302,6 +347,51 @@ defmodule Sentry.Test do
     end
   end
 
+  @doc """
+  Pops all the collected transactions from the current process.
+
+  This function returns a list of all the transactions that have been collected from the current
+  process and all the processes that were allowed through it. If the current process
+  is not collecting transactions, this function raises an error.
+
+  After this function returns, the current process will still be collecting transactions, but
+  the collected transactions will be reset to `[]`.
+
+  ## Examples
+
+      iex> Sentry.Test.start_collecting_sentry_reports()
+      :ok
+      iex> Sentry.send_transaction(Sentry.Transaction.new(%{span_id: "123", spans: []}))
+      {:ok, ""}
+      iex> [%Sentry.Transaction{}] = Sentry.Test.pop_sentry_transactions()
+
+  """
+  @doc since: "10.2.0"
+  @spec pop_sentry_transactions(pid()) :: [Sentry.Transaction.t()]
+  def pop_sentry_transactions(owner_pid \\ self()) when is_pid(owner_pid) do
+    result =
+      try do
+        NimbleOwnership.get_and_update(@server, owner_pid, @transaction_key, fn
+          nil -> {:not_collecting, []}
+          transactions when is_list(transactions) -> {transactions, []}
+        end)
+      catch
+        :exit, {:noproc, _} ->
+          raise ArgumentError, "not collecting reported transactions from #{inspect(owner_pid)}"
+      end
+
+    case result do
+      {:ok, :not_collecting} ->
+        raise ArgumentError, "not collecting reported transactions from #{inspect(owner_pid)}"
+
+      {:ok, transactions} ->
+        transactions
+
+      {:error, error} when is_exception(error) ->
+        raise ArgumentError, "cannot pop Sentry transactions: #{Exception.message(error)}"
+    end
+  end
+
   ## Helpers
 
   defp ensure_ownership_server_started do