Add support for sending transactions

- Add Transaction struct
- Add Sentry.send_transaction
- Add support for collecting transactions in tests

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

@@ -15,8 +15,9 @@ defmodule Sentry.Client do
     Event,
     Interfaces,
     LoggerUtils,
-    Transport,
-    Options
+    Options,
+    Transaction,
+    Transport
   }
 
   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 = NimbleOptions.validate!(opts, Options.send_transaction_schema())
+
+    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,21 @@ 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,
+    Transaction,
+    UUID
+  }
 
   @type t() :: %__MODULE__{
           event_id: UUID.t(),
-          items: [Event.t() | Attachment.t() | CheckIn.t() | ClientReport.t(), ...]
+          items: [
+            Attachment.t() | CheckIn.t() | ClientReport.t() | Event.t() | Transaction.t()
+          ]
         }
 
   @enforce_keys [:event_id, :items]
@@ -46,13 +56,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 +154,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/options.ex

@@ -1,7 +1,7 @@
 defmodule Sentry.Options do
   @moduledoc false
 
-  @send_event_opts_schema_as_keyword [
+  @common_opts_schema_as_keyword [
     result: [
       type: {:in, [:sync, :none]},
       doc: """
@@ -15,29 +15,6 @@ defmodule Sentry.Options do
         call ends up being successful or not.
       """
     ],
-    sample_rate: [
-      type: :float,
-      doc: """
-      Same as the global `:sample_rate` configuration, but applied only to
-      this call. See the module documentation. *Available since v10.0.0*.
-      """
-    ],
-    before_send: [
-      type: {:or, [{:fun, 1}, {:tuple, [:atom, :atom]}]},
-      type_doc: "`t:before_send_event_callback/0`",
-      doc: """
-      Same as the global `:before_send` configuration, but
-      applied only to this call. See the module documentation. *Available since v10.0.0*.
-      """
-    ],
-    after_send_event: [
-      type: {:or, [{:fun, 2}, {:tuple, [:atom, :atom]}]},
-      type_doc: "`t:after_send_event_callback/0`",
-      doc: """
-      Same as the global `:after_send_event` configuration, but
-      applied only to this call. See the module documentation. *Available since v10.0.0*.
-      """
-    ],
     client: [
       type: :atom,
       type_doc: "`t:module/0`",
@@ -54,6 +31,32 @@ defmodule Sentry.Options do
     ]
   ]
 
+  @send_event_opts_schema_as_keyword Keyword.merge(@common_opts_schema_as_keyword,
+                                       sample_rate: [
+                                         type: :float,
+                                         doc: """
+                                         Same as the global `:sample_rate` configuration, but applied only to
+                                         this call. See the module documentation. *Available since v10.0.0*.
+                                         """
+                                       ],
+                                       before_send: [
+                                         type: {:or, [{:fun, 1}, {:tuple, [:atom, :atom]}]},
+                                         type_doc: "`t:before_send_event_callback/0`",
+                                         doc: """
+                                         Same as the global `:before_send` configuration, but
+                                         applied only to this call. See the module documentation. *Available since v10.0.0*.
+                                         """
+                                       ],
+                                       after_send_event: [
+                                         type: {:or, [{:fun, 2}, {:tuple, [:atom, :atom]}]},
+                                         type_doc: "`t:after_send_event_callback/0`",
+                                         doc: """
+                                         Same as the global `:after_send_event` configuration, but
+                                         applied only to this call. See the module documentation. *Available since v10.0.0*.
+                                         """
+                                       ]
+                                     )
+
   @create_event_opts_schema_as_keyword [
     exception: [
       type: {:custom, Sentry.Event, :__validate_exception__, [:exception]},
@@ -191,6 +194,10 @@ defmodule Sentry.Options do
 
   @create_event_opts_schema NimbleOptions.new!(@create_event_opts_schema_as_keyword)
 
+  @send_transaction_opts_schema_as_keyword Keyword.merge(@common_opts_schema_as_keyword, [])
+
+  @send_transaction_opts_schema NimbleOptions.new!(@send_transaction_opts_schema_as_keyword)
+
   @spec send_event_schema() :: NimbleOptions.t()
   def send_event_schema do
     @send_event_opts_schema
@@ -206,6 +213,11 @@ defmodule Sentry.Options do
     @create_event_opts_schema
   end
 
+  @spec send_transaction_schema() :: NimbleOptions.t()
+  def send_transaction_schema do
+    @send_transaction_opts_schema
+  end
+
   @spec docs_for(atom()) :: String.t()
   def docs_for(type)