Merge pull request getsentry#106 from planswell/capture_message

Add capture_message

lib/sentry.ex

@@ -123,6 +123,17 @@ defmodule Sentry do
     end
   end
 
+  @doc """
+  Reports a message to Sentry.
+  """
+  @spec capture_message(String.t, Keyword.t) :: {:ok, String.t} | :error
+  def capture_message(message, opts \\ []) do
+    opts
+    |> Keyword.put(:message, message)
+    |> Event.create_event()
+    |> send_event()
+  end
+
   @doc """
     Sends a `Sentry.Event`
   """

lib/sentry/event.ex

@@ -26,8 +26,10 @@ defmodule Sentry.Event do
             breadcrumbs: []
 
   @doc """
-  Transforms an Exception to a Sentry event.
+  Creates an Event struct out of context collected and options 
   ## Options
+    * `:exception` - expection
+    * `:message` - message
     * `:stacktrace` - a list of Exception.stacktrace()
     * `:extra` - map of extra context
     * `:user` - map of user context
@@ -36,37 +38,33 @@ defmodule Sentry.Event do
     * `:breadcrumbs` - list of breadcrumbs
     * `:level` - error level
   """
-  @spec transform_exception(Exception.t, Keyword.t) :: %Event{}
-  def transform_exception(exception, opts) do
+  def create_event(opts) do
     %{user: user_context,
-     tags: tags_context,
-     extra: extra_context,
-     breadcrumbs: breadcrumbs_context,
-     request: request_context} = Sentry.Context.get_all()
+      tags: tags_context,
+      extra: extra_context,
+      breadcrumbs: breadcrumbs_context,
+      request: request_context} = Sentry.Context.get_all()
+
+    exception = Keyword.get(opts, :exception)
+
+    message = Keyword.get(opts, :message)
 
     stacktrace = Keyword.get(opts, :stacktrace, [])
 
     extra = extra_context
             |> Map.merge(Keyword.get(opts, :extra, %{}))
     user = user_context
-            |> Map.merge(Keyword.get(opts, :user, %{}))
+           |> Map.merge(Keyword.get(opts, :user, %{}))
     tags = Application.get_env(:sentry, :tags, %{})
-            |> Map.merge(tags_context)
-            |> Map.merge(Keyword.get(opts, :tags, %{}))
+           |> Map.merge(tags_context)
+           |> Map.merge(Keyword.get(opts, :tags, %{}))
     request = request_context
               |> Map.merge(Keyword.get(opts, :request, %{}))
     breadcrumbs = Keyword.get(opts, :breadcrumbs, [])
                   |> Kernel.++(breadcrumbs_context)
 
     level = Keyword.get(opts, :level, "error")
 
-    exception = Exception.normalize(:error, exception)
-
-    message = :error
-      |> Exception.format_banner(exception)
-      |> String.trim("*")
-      |> String.trim
-
     release = Application.get_env(:sentry, :release)
 
     server_name = Application.get_env(:sentry, :server_name)
@@ -80,7 +78,7 @@ defmodule Sentry.Event do
       platform: "elixir",
       environment: env,
       server_name: server_name,
-      exception: [%{type: exception.__struct__, value: Exception.message(exception)}],
+      exception: exception,
       stacktrace: %{
         frames: stacktrace_to_frames(stacktrace)
       },
@@ -89,9 +87,37 @@ defmodule Sentry.Event do
       tags: tags,
       user: user,
       breadcrumbs: breadcrumbs,
+      request: request
     }
     |> add_metadata()
-    |> Map.put(:request, request)
+  end
+
+  @doc """
+  Transforms an Exception to a Sentry event.
+  ## Options
+    * `:stacktrace` - a list of Exception.stacktrace()
+    * `:extra` - map of extra context
+    * `:user` - map of user context
+    * `:tags` - map of tags context
+    * `:request` - map of request context
+    * `:breadcrumbs` - list of breadcrumbs
+    * `:level` - error level
+  """
+  @spec transform_exception(Exception.t, Keyword.t) :: %Event{}
+  def transform_exception(exception, opts) do
+    exception = Exception.normalize(:error, exception)
+
+    message = :error
+      |> Exception.format_banner(exception)
+      |> String.trim("*")
+      |> String.trim
+
+    exception = [%{type: exception.__struct__, value: Exception.message(exception)}]
+
+    opts
+    |> Keyword.put(:exception, exception)
+    |> Keyword.put(:message, message)
+    |> create_event()
   end
 
   @spec add_metadata(%Event{}) :: %Event{}

test/event_test.exs

@@ -21,7 +21,7 @@ defmodule Sentry.EventTest do
        value: "function Sentry.Event.not_a_function/0 is undefined or private"}
     ]
     assert event.level == "error"
-    assert event.message()== "(UndefinedFunctionError) function Sentry.Event.not_a_function/0 is undefined or private"
+    assert event.message == "(UndefinedFunctionError) function Sentry.Event.not_a_function/0 is undefined or private"
     assert is_binary(event.server_name)
     assert event.stacktrace == %{frames: Enum.reverse([
       %{filename: nil, function: "Sentry.Event.not_a_function()", lineno: nil, module: Sentry.Event},
@@ -46,4 +46,29 @@ defmodule Sentry.EventTest do
     event = event_generated_by_exception(%{extra_data: "data"})
     assert event.extra == %{extra_data: "data"}
   end
+
+  test "create_event works for message" do
+    assert Event.create_event(message: "Test message")
+           |> Map.put(:event_id, nil)
+           |> Map.put(:server_name, nil)
+           |> Map.put(:timestamp, nil)
+    ==
+    %Sentry.Event{
+      breadcrumbs: [],
+      culprit: nil,
+      environment: :test,
+      event_id: nil,
+      exception: nil,
+      extra: %{},
+      level: "error",
+      message: "Test message",
+      platform: "elixir",
+      release: nil,
+      request: %{},
+      server_name: nil,
+      stacktrace: %{frames: []},
+      tags: %{},
+      timestamp: nil,
+      user: %{}}
+  end
 end

test/sentry_test.exs

@@ -20,5 +20,6 @@ defmodule SentryTest do
 
    assert {:ok, _} = Sentry.capture_exception(%RuntimeError{message: "error"}, [event_source: :plug])
    assert :excluded = Sentry.capture_exception(%ArithmeticError{message: "error"}, [event_source: :plug])
+   assert {:ok, _} = Sentry.capture_message("RuntimeError: error", [event_source: :plug])
   end
 end