conditionally add client_reports

Author: savhappy

lib/sentry.ex

@@ -341,6 +341,8 @@ defmodule Sentry do
     cond do
       is_nil(event.message) and event.exception == [] ->
         LoggerUtils.log("Cannot report event without message or exception: #{inspect(event)}")
+        Client.record_discarded_event(:event_processor, "no message or exception")
+        # record discarded_event here
         :ignored
 
       # If we're in test mode, let's send the event down the pipeline anyway.

lib/sentry/application.ex

@@ -19,14 +19,18 @@ defmodule Sentry.Application do
         []
       end
 
+    client_report_enabled =
+      if Config.dsn() && Config.send_client_reports?() do
+        Sentry.ClientReport
+      end
+
     integrations_config = Config.integrations()
 
     children =
       [
         {Registry, keys: :unique, name: Sentry.Transport.SenderRegistry},
         Sentry.Sources,
         Sentry.Dedupe,
-        # Sentry.ClientReports,
         {Sentry.Integrations.CheckInIDMappings,
          [
            max_expected_check_in_time:
@@ -36,6 +40,13 @@ defmodule Sentry.Application do
         maybe_http_client_spec ++
         [Sentry.Transport.SenderPool]
 
+    # only add client_reports if enabled
+    children =
+      case client_report_enabled do
+        nil -> children
+        _ -> children ++ client_report_enabled
+      end
+
     cache_loaded_applications()
 
     with {:ok, pid} <-

lib/sentry/client.ex

@@ -15,7 +15,8 @@ defmodule Sentry.Client do
     Interfaces,
     LoggerUtils,
     Transport,
-    Options
+    Options,
+    ClientReport
   }
 
   require Logger
@@ -91,6 +92,33 @@ defmodule Sentry.Client do
     end
   end
 
+  @spec send_client_report(ClientReport.t()) ::
+          {:ok, client_report_id :: String.t()} | {:error, ClientError.t()}
+  def send_client_report(%ClientReport{} = client_report) do
+    # We don't pass options because this is internal. But should we use default client or users?
+    client = Config.client()
+
+    # This is a "private" option, only really used in testing.
+    request_retries =
+      Application.get_env(:sentry, :request_retries, Transport.default_retries())
+
+    send_result =
+      client_report
+      |> Envelope.from_client_report()
+      |> Transport.encode_and_post_envelope(client, request_retries)
+
+    send_result
+  end
+
+  def record_discarded_event(reason, category) do
+    # if Config.send_client_reports?() == true do
+    # call to client report genserver
+    ClientReport.add_discarded_event({reason, category}) |> IO.inspect()
+    # end
+
+    :ok
+  end
+
   defp sample_event(sample_rate) do
     cond do
       sample_rate == 1 -> :ok

lib/sentry/client_report.ex

@@ -10,7 +10,7 @@ defmodule Sentry.ClientReport do
   @typedoc since: "10.0.0"
 
   use GenServer
-  alias Sentry.Transport
+  alias Sentry.Client
 
   @typedoc """
   The possible reasons of the discarded event.
@@ -31,7 +31,8 @@ defmodule Sentry.ClientReport do
   """
   @type t() :: %__MODULE__{
           timestamp: String.t() | number(),
-          discarded_events: %{{String.t(), reasons()} => pos_integer()}
+          discarded_events:
+            list(%{reason: reasons(), category: String.t(), quantity: pos_integer()})
         }
 
   defstruct [:timestamp, :discarded_events]
@@ -56,10 +57,10 @@ defmodule Sentry.ClientReport do
     GenServer.start_link(__MODULE__, %__MODULE__{}, name: __MODULE__)
   end
 
-  @spec add_discarded_event(String.t(), String.t()) :: :ok
-  def add_discarded_event(type, reason) do
+  @spec add_discarded_event({reasons(), String.t()}) :: :ok
+  def add_discarded_event({reason, category}) do
     if Enum.member?(@client_report_reasons, reason) do
-      GenServer.cast(__MODULE__, {:add_discarded_event, {type, reason}})
+      GenServer.cast(__MODULE__, {:add_discarded_event, {reason, category}})
     end
 
     :ok
@@ -72,25 +73,33 @@ defmodule Sentry.ClientReport do
   end
 
   @impl true
-  def handle_cast({:add_discarded_event, {type, reason}}, client_report) do
+  def handle_cast({:add_discarded_event, {reason, category}}, client_report) do
     if client_report.discarded_events == nil do
-      {:noreply, %{client_report | discarded_events: %{{type, reason} => 1}}}
+      {:noreply, %{client_report | discarded_events: %{{reason, category} => 1}}}
     else
-      discarded_events = Map.update(client_report.discarded_events, {type, reason}, 1, &(&1 + 1))
+      discarded_events =
+        Map.update(client_report.discarded_events, {reason, category}, 1, &(&1 + 1))
+
       {:noreply, %{client_report | discarded_events: discarded_events}}
     end
   end
 
   @impl true
   def handle_info(:send_report, state) do
     if state.discarded_events != nil do
-      updated_state = %{state | timestamp: timestamp()}
-      # Transport.send_client_report(updated_state)
+      updated_state = %{
+        state
+        | timestamp: timestamp(),
+          discarded_events: transform_map(state.discarded_events)
+      }
+
+      Client.send_client_report(updated_state)
       schedule_report()
       {:noreply, %__MODULE__{}}
     else
       # state is nil so nothing to send but keep looping
       schedule_report()
+      IO.inspect(state)
       {:noreply, state}
     end
   end
@@ -105,4 +114,15 @@ defmodule Sentry.ClientReport do
     |> DateTime.to_iso8601()
     |> String.trim_trailing("Z")
   end
+
+  defp transform_map(discarded_events_map) do
+    discarded_events_map
+    |> Enum.map(fn {{reason, category}, quantity} ->
+      %{
+        reason: reason,
+        category: category,
+        quantity: quantity
+      }
+    end)
+  end
 end