exception_handling 3.2.0.pre.dc.0 → 3.2.0.pre.dc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a1419e36b2b184e6e49ad6b943537b1f5efaf54680aef66251093c242e93168
-  data.tar.gz: 641de9b2e454c20cb754469fce0f781136baefb14af6913ab25fce3f0263bae4
+  metadata.gz: f292c98e64a5e880cc6a09979d1b9dbebd1fbe2a074f9d98a3a84391d6829107
+  data.tar.gz: b69dcabd0bada51da5ff4010c29a6aeb42e7a44f79841c5f7e14a55990a488fe
 SHA512:
-  metadata.gz: d3ba9e37ec6c14e508341b604df6ffaeed7c88106ca19305f69a2990f6eefcf03a8ae41a3fb6f7245165e00cb910940ae99842f6d73d9c641d8a9f9c2293a883
-  data.tar.gz: a9402fb31a6cce4d2181d9b304376412c7acbf63ffb4e592615da2a2bfd77330c8e6ef1a9bb4c3e1428f6dd9bec32295c5f572860117912cb4f34c6f9e49df27
+  metadata.gz: 9bc146dff9c619c77c3f9b17bac3b83bbb48787df2a07aa368a8fdee2ebd2d35260b903424abef82d91a3f5a75d44561cbb0812159ab27d9e4b5c7ff7dd5a493
+  data.tar.gz: e2ff09d2805cafc8d18993051c4ac568168a73a8de9eab1074de69de819b2e7025e7bd4eb6339f2a06b8ccfa4ab86c2f36f65e89052132f0b416924f8623c274

data/CHANGELOG.md

@@ -6,7 +6,8 @@ Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [3.2.0] - 2026-08-04
 ### Added
-- Optional Sentry notifications from `send_external_notifications` when the `Sentry` constant is defined
+- Optional Sentry notifications from `send_external_notifications` via explicit `ExceptionHandling.enable_sentry` (requires `Sentry` to be defined and initialized)
+- Sentry events include ExceptionHandling context, tags, controller name, and filter-based fingerprinting (aligned with Honeybadger grouping via `filter_name`)
 - `send_to_sentry` exception filter flag (default `false`); filters with `send_to_honeybadger: true` also send to Sentry to ease migration
 
 ## [3.1.2] - 2024-05-08

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    exception_handling (3.2.0.pre.dc.0)
+    exception_handling (3.2.0.pre.dc.1)
       activesupport (>= 5.2)
       contextual_logger (~> 1.0)
       escalate (~> 0.3)

data/README.md

@@ -44,15 +44,25 @@ ExceptionHandling.add_honeybadger_tag_from_log_context("tag-name", path: ["path"
 ExceptionHandling notifies configured external services from `log_error` (and related paths):
 
 - **Honeybadger** — when the `Honeybadger` constant is defined
-- **Sentry** — when the `Sentry` constant is defined (for example after initializing the Sentry Ruby SDK in your app)
+- **Sentry** — only after you call `ExceptionHandling.enable_sentry` (requires `Sentry` to be defined and initialized)
 
-Both can run at the same time. This gem does not depend on `sentry-ruby`; initialize Sentry in the host application.
+Both can run at the same time. This gem does not depend on `sentry-ruby`; initialize Sentry in the host application, then opt in:
+
+```ruby
+Sentry.init do |config|
+  config.dsn = ENV["SENTRY_DSN"]
+end
+
+ExceptionHandling.enable_sentry
+```
+
+When enabled, ExceptionHandling sends the same contextual sections it builds for Honeybadger (request/session/environment/log context, etc.), maps tags into Sentry tag key/values, sets controller context when present, and fingerprints matched filters by `filter_name` so grouping stays aligned across services.
 
 Matched exception filters in `exception_filters.yml` control delivery:
 
-- `send_to_honeybadger: true` — send to Honeybadger (and also to Sentry during migration)
-- `send_to_sentry: true` — send to Sentry
-- Unmatched exceptions are sent when the corresponding service is defined
+- `send_to_honeybadger: true` — send to Honeybadger (and also to Sentry during migration, when Sentry is enabled)
+- `send_to_sentry: true` — send to Sentry (when Sentry is enabled)
+- Unmatched exceptions are sent when the corresponding service is active
 - Matched filters with both flags false skip both services
 
 ## Usage

data/lib/exception_handling/exception_info.rb

@@ -79,7 +79,7 @@ module ExceptionHandling
     end
 
     def send_to_sentry?
-      ExceptionHandling.sentry_defined? && (
+      ExceptionHandling.sentry_enabled? && (
         !exception_description ||
           exception_description.send_to_sentry ||
           exception_description.send_to_honeybadger

data/lib/exception_handling/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ExceptionHandling
-  VERSION = '3.2.0.pre.dc.0'
+  VERSION = '3.2.0.pre.dc.1'
 end

data/lib/exception_handling.rb

@@ -211,7 +211,7 @@ module ExceptionHandling # never included
       if honeybadger_defined?
         results[:honeybadger_status] = send_exception_to_honeybadger_unless_filtered(exception_info)
       end
-      if sentry_defined?
+      if sentry_enabled?
         results[:sentry_status] = send_exception_to_sentry_unless_filtered(exception_info)
       end
       results
@@ -268,8 +268,16 @@ module ExceptionHandling # never included
     # Returns :success or :failure
     #
     def send_exception_to_sentry(exception_info)
-      exception = exception_info.exception
-      response = Sentry.capture_exception(exception)
+      exception             = exception_info.exception
+      exception_description = exception_info.exception_description
+
+      response = Sentry.capture_exception(exception) do |scope|
+        tags = tags_hash_for_sentry(exception_info)
+        scope.set_tags(tags) if tags.any?
+        scope.set_context("exception_handling", exception_info.honeybadger_context_data)
+        scope.set_context("controller", { name: exception_info.controller_name }) if exception_info.controller_name.present?
+        scope.set_fingerprint([exception_description.filter_name.to_s]) if exception_description
+      end
       response ? :success : :failure
     rescue Exception => ex
       warn("ExceptionHandling.send_exception_to_sentry rescued exception while logging #{exception_info.exception_context}:\n#{exception.class}: #{exception.message}:\n#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}")
@@ -285,10 +293,19 @@ module ExceptionHandling # never included
     end
 
     #
-    # Check if Sentry defined.
+    # Whether ExceptionHandling should notify Sentry. Off by default; call enable_sentry after Sentry.init.
+    #
+    def sentry_enabled?
+      !!@sentry_enabled
+    end
+
+    #
+    # Opt in to Sentry notifications. Requires the Sentry constant and a prior Sentry.init.
     #
-    def sentry_defined?
-      Object.const_defined?("Sentry")
+    def enable_sentry
+      Object.const_defined?("Sentry") or raise ArgumentError, "Sentry is not defined"
+      Sentry.initialized? or raise ArgumentError, "Sentry is not initialized"
+      @sentry_enabled = true
     end
 
     #
@@ -406,6 +423,24 @@ module ExceptionHandling # never included
       ).uniq
     end
 
+    # Convert Honeybadger-style tag strings into a Sentry tags hash.
+    # Tags containing ":" are split into key/value; others become key => true.
+    #
+    # @param exception_info [ExceptionInfo]
+    # @return [Hash{String => String, TrueClass}]
+    def tags_hash_for_sentry(exception_info)
+      tags_for_honeybadger(exception_info).each_with_object({}) do |tag, hash|
+        tag = tag.to_s.strip
+        next if tag.empty?
+
+        if (separator_index = tag.index(":"))
+          hash[tag[0...separator_index]] = tag[(separator_index + 1)..]
+        else
+          hash[tag] = true
+        end
+      end
+    end
+
     # @param exception [Exception]
     #
     # @return [Array<String>]

data/spec/unit/exception_handling/exception_info_spec.rb

@@ -453,15 +453,15 @@ module ExceptionHandling
     end
 
     context "send_to_sentry?" do
-      it "be enabled when Sentry is defined and exception is not in the filter list" do
-        allow(ExceptionHandling).to receive(:sentry_defined?).and_return(true)
+      it "be enabled when Sentry is enabled and exception is not in the filter list" do
+        allow(ExceptionHandling).to receive(:sentry_enabled?).and_return(true)
         exception_info = ExceptionInfo.new(StandardError.new("something went wrong"), nil, Time.now)
         expect(exception_info.exception_description).to be_nil
         expect(exception_info.send_to_sentry?).to eq(true)
       end
 
-      it "be enabled when Sentry is defined and filter has send_to_sentry true" do
-        allow(ExceptionHandling).to receive(:sentry_defined?).and_return(true)
+      it "be enabled when Sentry is enabled and filter has send_to_sentry true" do
+        allow(ExceptionHandling).to receive(:sentry_enabled?).and_return(true)
         exception = StandardError.new("No route matches")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
         allow(exception_info.exception_description).to receive(:send_to_sentry).and_return(true)
@@ -469,8 +469,8 @@ module ExceptionHandling
         expect(exception_info.send_to_sentry?).to eq(true)
       end
 
-      it "be enabled when Sentry is defined and filter has send_to_honeybadger true only" do
-        allow(ExceptionHandling).to receive(:sentry_defined?).and_return(true)
+      it "be enabled when Sentry is enabled and filter has send_to_honeybadger true only" do
+        allow(ExceptionHandling).to receive(:sentry_enabled?).and_return(true)
         exception = StandardError.new("No route matches")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
         allow(exception_info.exception_description).to receive(:send_to_sentry).and_return(false)
@@ -478,8 +478,8 @@ module ExceptionHandling
         expect(exception_info.send_to_sentry?).to eq(true)
       end
 
-      it "be disabled when Sentry is defined and both filter flags are false" do
-        allow(ExceptionHandling).to receive(:sentry_defined?).and_return(true)
+      it "be disabled when Sentry is enabled and both filter flags are false" do
+        allow(ExceptionHandling).to receive(:sentry_enabled?).and_return(true)
         exception = StandardError.new("No route matches")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
         allow(exception_info.exception_description).to receive(:send_to_sentry).and_return(false)
@@ -487,8 +487,8 @@ module ExceptionHandling
         expect(exception_info.send_to_sentry?).to eq(false)
       end
 
-      it "be disabled when Sentry is not defined" do
-        allow(ExceptionHandling).to receive(:sentry_defined?).and_return(false)
+      it "be disabled when Sentry is not enabled" do
+        allow(ExceptionHandling).to receive(:sentry_enabled?).and_return(false)
         exception_info = ExceptionInfo.new(StandardError.new("something went wrong"), nil, Time.now)
         expect(exception_info.send_to_sentry?).to eq(false)
       end

data/spec/unit/exception_handling_spec.rb

@@ -111,6 +111,7 @@ describe ExceptionHandling do
     # Reset this for every test since they are applied to the class
     ExceptionHandling.honeybadger_auto_tagger = nil
     ExceptionHandling.clear_honeybadger_tags_from_log_context
+    ExceptionHandling.instance_variable_set(:@sentry_enabled, false)
   end
 
   context "with warn and honeybadger notify stubbed" do
@@ -691,11 +692,31 @@ describe ExceptionHandling do
       end
 
       context "Sentry integration" do
-        context "with Sentry not defined" do
-          before do
-            allow(ExceptionHandling).to receive(:sentry_defined?).and_return(false)
+        context "enable_sentry" do
+          it "raises when Sentry is not defined" do
+            hide_const("Sentry") if Object.const_defined?("Sentry")
+            expect { ExceptionHandling.enable_sentry }.to raise_error(ArgumentError, "Sentry is not defined")
+            expect(ExceptionHandling.sentry_enabled?).to eq(false)
+          end
+
+          it "raises when Sentry is defined but not initialized" do
+            stub_const("Sentry", Module.new do
+              def self.initialized?; false; end
+            end)
+            expect { ExceptionHandling.enable_sentry }.to raise_error(ArgumentError, "Sentry is not initialized")
+            expect(ExceptionHandling.sentry_enabled?).to eq(false)
           end
 
+          it "enables Sentry notifications when Sentry is defined and initialized" do
+            stub_const("Sentry", Module.new do
+              def self.initialized?; true; end
+            end)
+            ExceptionHandling.enable_sentry
+            expect(ExceptionHandling.sentry_enabled?).to eq(true)
+          end
+        end
+
+        context "with Sentry not enabled" do
           it "not invoke send_exception_to_sentry when log_error is executed" do
             expect(ExceptionHandling).to_not receive(:send_exception_to_sentry)
             ExceptionHandling.log_error(exception_1)
@@ -705,11 +726,21 @@ describe ExceptionHandling do
             expect(ExceptionHandling).to_not receive(:send_exception_to_sentry)
             ExceptionHandling.ensure_safe { raise exception_1 }
           end
+
+          it "not send to Sentry even when the Sentry constant is defined" do
+            stub_const("Sentry", Module.new do
+              def self.initialized?; true; end
+              def self.capture_exception(_exception); end
+            end)
+            expect(Sentry).to_not receive(:capture_exception)
+            ExceptionHandling.log_error(exception_1)
+          end
         end
 
-        context "with Sentry defined" do
+        context "with Sentry enabled" do
           let(:sentry_module) do
             Module.new do
+              def self.initialized?; true; end
               def self.capture_exception(_exception); end
             end
           end
@@ -717,6 +748,7 @@ describe ExceptionHandling do
           before do
             stub_const("Sentry", sentry_module)
             allow(Sentry).to receive(:capture_exception).and_return(Object.new)
+            ExceptionHandling.enable_sentry
           end
 
           it "not send_exception_to_sentry when log_warning is executed" do
@@ -749,7 +781,30 @@ describe ExceptionHandling do
             ExceptionHandling.log_error(exception_1)
           end
 
-          it "also notify Honeybadger when both are defined" do
+          it "passes context, tags, and filter fingerprint to Sentry via the scope" do
+            scope = double("Sentry::Scope")
+            expect(scope).to receive(:set_context).with("exception_handling", hash_including(:error_class, :timestamp, :server, :backtrace))
+            expect(scope).to receive(:set_tags).with(hash_including("critical" => true, "team" => "platform"))
+            expect(scope).to receive(:set_fingerprint).with(["Test Exception"])
+            expect(scope).to receive(:set_context).with("controller", { name: "some_controller" })
+
+            expect(Sentry).to receive(:capture_exception).with(instance_of(StandardError)).and_yield(scope).and_return(Object.new)
+
+            env = { server: "fe98" }
+            parameters = { advertiser_id: 435, controller: "some_controller" }
+            session = { username: "jsmith" }
+            controller = create_dummy_controller(env, parameters, session, "host/path")
+            allow(ExceptionHandling).to receive(:server_name).and_return("invoca_fe98")
+
+            ExceptionHandling.log_error(
+              StandardError.new("Some Exception"),
+              { "SERVER_NAME" => "exceptional.com" },
+              controller,
+              honeybadger_tags: ["critical", "team:platform"]
+            )
+          end
+
+          it "also notify Honeybadger when both are available" do
             expect(Honeybadger).to receive(:notify).with(any_args).and_return("hb-id")
             expect(Sentry).to receive(:capture_exception).with(exception_1).and_return(Object.new)
             ExceptionHandling.log_error(exception_1)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: exception_handling
 version: !ruby/object:Gem::Version
-  version: 3.2.0.pre.dc.0
+  version: 3.2.0.pre.dc.1
 platform: ruby
 authors:
 - Invoca
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport