exception_handling 2.17.0.pre.tstarck.1 → 3.0.0.pre.2

data/spec/unit/exception_handling_spec.rb

@@ -110,7 +110,6 @@ describe ExceptionHandling do
   before(:each) 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
   end
 
   context "with warn and honeybadger notify stubbed" do
@@ -132,19 +131,9 @@ describe ExceptionHandling do
         expect(ExceptionHandling.logger.singleton_class.ancestors.*.name).to eq(ancestors)
       end
 
-      it "allows logger = nil (no deprecation warning)" do
-        expect(STDERR).to receive(:puts).with(/DEPRECATION WARNING/).never
+      it "allows logger = nil" do
         ExceptionHandling.logger = nil
-      end
-
-      it "[deprecated] mixes in ContextualLogger::Mixin if not there" do
-        expect(STDERR).to receive(:puts).with(/DEPRECATION WARNING: implicit extend with ContextualLogger::LoggerMixin is deprecated and will be removed from exception_handling 3\.0/)
-        logger = Logger.new('/dev/null')
-        ancestors = logger.singleton_class.ancestors.*.name
-
-        ExceptionHandling.logger = logger
-        expect(ExceptionHandling.logger).to be_kind_of(ContextualLogger::LoggerMixin)
-        expect(ExceptionHandling.logger.singleton_class.ancestors.*.name).to_not eq(ancestors)
+        expect { ExceptionHandling.logger }.to raise_error(ArgumentError, "You must assign a value to ExceptionHandling.logger")
       end
 
       context "#log_error" do
@@ -317,144 +306,53 @@ describe ExceptionHandling do
 
     context "Exception Handling" do
       context "default_metric_name" do
-        context "with include_prefix true" do
-          it "logs a deprecation warning" do
-            expect { ExceptionHandling.default_metric_name({}, StandardError.new('this is an exception'), false) }
-              .to output(/DEPRECATION WARNING: the 'expection_handling\.' prefix in ExceptionHandling::default_metric_name is deprecated/).to_stderr
-          end
-
-          context "when metric_name is present in exception_data" do
-            it "include metric_name in resulting metric name" do
-              exception = StandardError.new('this is an exception')
-              metric    = ExceptionHandling.default_metric_name({ 'metric_name' => 'special_metric' }, exception, true, include_prefix: true)
-              expect(metric).to eq('exception_handling.special_metric')
-            end
-          end
-
-          context "when metric_name is not present in exception_data" do
-            it "return exception_handling.warning when using log warning" do
-              warning = ExceptionHandling::Warning.new('this is a warning')
-              metric  = ExceptionHandling.default_metric_name({}, warning, false, include_prefix: true)
-              expect(metric).to eq('exception_handling.warning')
-            end
-
-            it "return exception_handling.exception when using log error" do
-              exception = StandardError.new('this is an exception')
-              metric    = ExceptionHandling.default_metric_name({}, exception, false, include_prefix: true)
-              expect(metric).to eq('exception_handling.exception')
-            end
-
-            context "when using log error with treat_like_warning" do
-              it "return exception_handling.unforwarded_exception when exception not present" do
-                metric = ExceptionHandling.default_metric_name({}, nil, true, include_prefix: true)
-                expect(metric).to eq('exception_handling.unforwarded_exception')
-              end
-
-              it "return exception_handling.unforwarded_exception with exception classname when exception is present" do
-                module SomeModule
-                  class SomeException < StandardError
-                  end
-                end
-
-                exception = SomeModule::SomeException.new('this is an exception')
-                metric    = ExceptionHandling.default_metric_name({}, exception, true, include_prefix: true)
-                expect(metric).to eq('exception_handling.unforwarded_exception_SomeException')
-              end
-            end
+        context "when metric_name is present in exception_data" do
+          it "include metric_name in resulting metric name" do
+            exception = StandardError.new('this is an exception')
+            metric    = ExceptionHandling.default_metric_name({ 'metric_name' => 'special_metric' }, exception, true)
+            expect(metric).to eq('special_metric')
           end
         end
 
-        context "with include_prefix false" do
-          context "when metric_name is present in exception_data" do
-            it "include metric_name in resulting metric name" do
-              exception = StandardError.new('this is an exception')
-              metric    = ExceptionHandling.default_metric_name({ 'metric_name' => 'special_metric' }, exception, true, include_prefix: false)
-              expect(metric).to eq('special_metric')
-            end
+        context "when metric_name is not present in exception_data" do
+          it "return exception_handling.warning when using log warning" do
+            warning = ExceptionHandling::Warning.new('this is a warning')
+            metric  = ExceptionHandling.default_metric_name({}, warning, false)
+            expect(metric).to eq('warning')
           end
 
-          context "when metric_name is not present in exception_data" do
-            it "return exception_handling.warning when using log warning" do
-              warning = ExceptionHandling::Warning.new('this is a warning')
-              metric  = ExceptionHandling.default_metric_name({}, warning, false, include_prefix: false)
-              expect(metric).to eq('warning')
-            end
+          it "return exception_handling.exception when using log error" do
+            exception = StandardError.new('this is an exception')
+            metric    = ExceptionHandling.default_metric_name({}, exception, false)
+            expect(metric).to eq('exception')
+          end
 
-            it "return exception_handling.exception when using log error" do
-              exception = StandardError.new('this is an exception')
-              metric    = ExceptionHandling.default_metric_name({}, exception, false, include_prefix: false)
-              expect(metric).to eq('exception')
+          context "when using log error with treat_like_warning" do
+            it "return exception_handling.unforwarded_exception when exception not present" do
+              metric = ExceptionHandling.default_metric_name({}, nil, true)
+              expect(metric).to eq('unforwarded_exception')
             end
 
-            context "when using log error with treat_like_warning" do
-              it "return exception_handling.unforwarded_exception when exception not present" do
-                metric = ExceptionHandling.default_metric_name({}, nil, true, include_prefix: false)
-                expect(metric).to eq('unforwarded_exception')
-              end
-
-              it "return exception_handling.unforwarded_exception with exception classname when exception is present" do
-                module SomeModule
-                  class SomeException < StandardError
-                  end
+            it "return exception_handling.unforwarded_exception with exception classname when exception is present" do
+              module SomeModule
+                class SomeException < StandardError
                 end
-
-                exception = SomeModule::SomeException.new('this is an exception')
-                metric    = ExceptionHandling.default_metric_name({}, exception, true, include_prefix: false)
-                expect(metric).to eq('unforwarded_exception_SomeException')
               end
+
+              exception = SomeModule::SomeException.new('this is an exception')
+              metric    = ExceptionHandling.default_metric_name({}, exception, true)
+              expect(metric).to eq('unforwarded_exception_SomeException')
             end
           end
         end
       end
 
-      context "default_honeybadger_metric_name" do
-        it "return exception_handling.honeybadger.success when status is :success" do
-          metric = ExceptionHandling.default_honeybadger_metric_name(:success)
-          expect(metric).to eq('exception_handling.honeybadger.success')
-        end
-
-        it "return exception_handling.honeybadger.failure when status is :failure" do
-          metric = ExceptionHandling.default_honeybadger_metric_name(:failure)
-          expect(metric).to eq('exception_handling.honeybadger.failure')
-        end
-
-        it "return exception_handling.honeybadger.skipped when status is :skipped" do
-          metric = ExceptionHandling.default_honeybadger_metric_name(:skipped)
-          expect(metric).to eq('exception_handling.honeybadger.skipped')
-        end
-
-        it "return exception_handling.honeybadger.unknown_status when status is not recognized" do
-          metric = ExceptionHandling.default_honeybadger_metric_name(nil)
-          expect(metric).to eq('exception_handling.honeybadger.unknown_status')
-        end
-      end
-
       context "ExceptionHandling.ensure_safe" do
         it "log an exception with call stack if an exception is raised." do
           expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, any_args)
           ExceptionHandling.ensure_safe { raise ArgumentError, "blah" }
         end
 
-        if ActionView::VERSION::MAJOR >= 5
-          it "log an exception with call stack if an ActionView template exception is raised." do
-            expect(ExceptionHandling.logger).to receive(:fatal).with(/\(Error:\d+\) \nActionView::Template::Error: \(blah\):\n /, any_args)
-            ExceptionHandling.ensure_safe do
-              begin
-                # Rails 5 made the switch from ActionView::TemplateError taking in the original exception
-                # as an argument to using the $! global to extract the original exception
-                raise ArgumentError, "blah"
-              rescue
-                raise ActionView::TemplateError.new({})
-              end
-            end
-          end
-        else
-          it "log an exception with call stack if an ActionView template exception is raised." do
-            expect(ExceptionHandling.logger).to receive(:fatal).with(/\(Error:\d+\) \nActionView::Template::Error: \(blah\):\n /, any_args)
-            ExceptionHandling.ensure_safe { raise ActionView::TemplateError.new({}, ArgumentError.new("blah")) }
-          end
-        end
-
         it "should not log an exception if an exception is not raised." do
           expect(ExceptionHandling.logger).to_not receive(:fatal)
           ExceptionHandling.ensure_safe { ; }
@@ -533,99 +431,6 @@ describe ExceptionHandling do
         end
       end
 
-      context "ExceptionHandling.ensure_escalation" do
-        before do
-          capture_notifications
-          ActionMailer::Base.deliveries.clear
-        end
-
-        it "log the exception as usual and send the proper email" do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, any_args)
-          ExceptionHandling.ensure_escalation("Favorite Feature") { raise ArgumentError, "blah" }
-          expect(ActionMailer::Base.deliveries.count).to eq(1)
-          expect(sent_notifications.size).to eq(1), sent_notifications.inspect
-
-          email = ActionMailer::Base.deliveries.last
-          expect(email.subject).to eq("#{ExceptionHandling.email_environment} Escalation: Favorite Feature")
-          expect(email.body.to_s).to match('ArgumentError: blah')
-          expect(email.body.to_s).to match(ExceptionHandling.last_exception_timestamp.to_s)
-        end
-
-        it "should not escalate if an exception is not raised." do
-          expect(ExceptionHandling.logger).to_not receive(:fatal)
-          ExceptionHandling.ensure_escalation('Ignored') { ; }
-          expect(ActionMailer::Base.deliveries.count).to eq(0)
-        end
-
-        it "log if the escalation email cannot be sent" do
-          expect_any_instance_of(Mail::Message).to receive(:deliver).and_raise(RuntimeError.new, "Delivery Error")
-          log_fatals = []
-          expect(ExceptionHandling.logger).to receive(:fatal).with(any_args).at_least(:once) do |*args|
-            log_fatals << args
-          end
-
-          ExceptionHandling.ensure_escalation("ensure context") { raise ArgumentError, "first_test_exception" }
-          expect(log_fatals[0].first).to match(/ArgumentError.*first_test_exception/)
-          expect(log_fatals[1].first).to match(/safe_email_deliver.*Delivery Error/m)
-
-          expect(log_fatals.size).to eq(2), log_fatals.inspect
-
-          expect(sent_notifications.size).to eq(1), sent_notifications.inspect # still sent to honeybadger
-        end
-
-        it "allow the caller to specify custom recipients" do
-          custom_recipients = ['something@invoca.com']
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, any_args)
-          ExceptionHandling.ensure_escalation("Favorite Feature", custom_recipients) { raise ArgumentError, "blah" }
-          expect(ActionMailer::Base.deliveries.count).to eq(1)
-          expect(sent_notifications.size).to eq(1), sent_notifications.inspect
-
-          email = ActionMailer::Base.deliveries.last
-          expect(email.subject).to eq("#{ExceptionHandling.email_environment} Escalation: Favorite Feature")
-          expect(email.body.to_s).to match('ArgumentError: blah')
-          expect(email.body.to_s).to match(ExceptionHandling.last_exception_timestamp.to_s)
-          expect(email.to).to eq(custom_recipients)
-        end
-      end
-
-      context "ExceptionHandling.ensure_alert" do
-        it "log the exception as usual and fire a sensu event" do
-          expect(ExceptionHandling::Sensu).to receive(:generate_event).with("Favorite Feature", "test context\nblah")
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, any_args)
-          ExceptionHandling.ensure_alert('Favorite Feature', 'test context') { raise ArgumentError, "blah" }
-        end
-
-        it "should not send sensu event if an exception is not raised." do
-          expect(ExceptionHandling.logger).to_not receive(:fatal)
-          expect(ExceptionHandling::Sensu).to_not receive(:generate_event)
-          ExceptionHandling.ensure_alert('Ignored', 'test context') { ; }
-        end
-
-        it "log if the sensu event could not be sent" do
-          expect(ExceptionHandling::Sensu).to receive(:send_event).with(anything) { raise "Failed to send" }
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/first_test_exception/, any_args)
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/Failed to send/, any_args)
-          ExceptionHandling.ensure_alert("Not Used", 'test context') { raise ArgumentError, "first_test_exception" }
-        end
-
-        it "log if the exception message is nil" do
-          expect(ExceptionHandling::Sensu).to receive(:generate_event).with("some alert", "test context\n")
-          ExceptionHandling.ensure_alert('some alert', 'test context') { raise_exception_with_nil_message }
-        end
-      end
-
-      context "ExceptionHandling.escalate_to_production_support" do
-        it "notify production support" do
-          subject = "Runtime Error found!"
-          exception = RuntimeError.new("Test")
-          recipients = ["prodsupport@example.com"]
-
-          expect(ExceptionHandling).to receive(:production_support_recipients).and_return(recipients).exactly(2)
-          expect(ExceptionHandling).to receive(:escalate).with(subject, exception, ExceptionHandling.last_exception_timestamp, recipients)
-          ExceptionHandling.escalate_to_production_support(exception, subject)
-        end
-      end
-
       context "exception timestamp" do
         before do
           Time.now_override = Time.parse('1986-5-21 4:17 am UTC')
@@ -1054,88 +859,6 @@ describe ExceptionHandling do
         ExceptionHandling.filter_list_filename = "./config/other_exception_filters.yml"
         expect(ExceptionHandling.exception_catalog).to_not eq(catalog)
       end
-
-      context "Exception Handling Mailer" do
-        EXPECTED_SMTP_HASH =
-          {
-            host: '127.0.0.1',
-            domain: 'localhost.localdomain',
-            from: 'server@example.com',
-            to: 'escalation@example.com'
-          }.freeze
-
-        [[true, false], [true, true]].each do |em_flag, synchrony_flag|
-          context "eventmachine_safe = #{em_flag} && eventmachine_synchrony = #{synchrony_flag}" do
-            before do
-              ExceptionHandling.eventmachine_safe       = em_flag
-              ExceptionHandling.eventmachine_synchrony  = synchrony_flag
-              EventMachineStub.block = nil
-              set_test_const('EventMachine', EventMachineStub)
-              set_test_const('EventMachine::Protocols', Module.new)
-              set_test_const('EventMachine::DNS', Module.new)
-              set_test_const('EventMachine::DNS::Resolver', DNSResolvStub)
-            end
-
-            after do
-              ExceptionHandling.eventmachine_safe       = false
-              ExceptionHandling.eventmachine_synchrony  = false
-            end
-
-            it "schedule EventMachine STMP when EventMachine defined" do
-              ActionMailer::Base.deliveries.clear
-
-              set_test_const('EventMachine::Protocols::SmtpClient', SmtpClientStub)
-
-              ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
-              EventMachineStub.block.call
-              expect(DNSResolvStub.callback_block).to be_truthy
-              DNSResolvStub.callback_block.call ['127.0.0.1']
-              expect((SmtpClientStub.send_hash & EXPECTED_SMTP_HASH.keys).map_hash { |_k, v| v.to_s }) .to eq(EXPECTED_SMTP_HASH), SmtpClientStub.send_hash.inspect
-              expect(SmtpClientStub.last_method).to eq((synchrony_flag ? :asend : :send))
-              expect(SmtpClientStub.send_hash[:content]).to match(/Exception to escalate/)
-              assert_emails 0, ActionMailer::Base.deliveries.*.to_s
-            end
-
-            it "pass the content as a proper rfc 2822 message" do
-              set_test_const('EventMachine::Protocols::SmtpClient', SmtpClientStub)
-              ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
-              EventMachineStub.block.call
-              expect(DNSResolvStub.callback_block).to be_truthy
-              DNSResolvStub.callback_block.call ['127.0.0.1']
-              expect(content = SmtpClientStub.send_hash[:content]).to be_truthy
-              expect(content).to match(/Content-Transfer-Encoding: 7bit/)
-              expect(content).to match(/\r\n\.\r\n\z/)
-            end
-
-            it "log fatal on EventMachine STMP errback" do
-              ActionMailer::Base.deliveries.clear
-
-              set_test_const('EventMachine::Protocols::SmtpClient', SmtpClientErrbackStub)
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Exception to escalate/, any_args)
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Failed to email by SMTP: "credential mismatch"/)
-
-              ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
-              EventMachineStub.block.call
-              expect(DNSResolvStub.callback_block).to be_truthy
-              DNSResolvStub.callback_block.call(['127.0.0.1'])
-              SmtpClientErrbackStub.block.call("credential mismatch")
-              expect((SmtpClientErrbackStub.send_hash & EXPECTED_SMTP_HASH.keys).map_hash { |_k, v| v.to_s }).to eq(EXPECTED_SMTP_HASH), SmtpClientErrbackStub.send_hash.inspect            end
-
-            it "log fatal on EventMachine dns resolver errback" do
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Exception to escalate/, any_args)
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Failed to resolv DNS for localhost: "softlayer sucks"/)
-
-              ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
-              EventMachineStub.block.call
-              DNSResolvStub.errback_block.call("softlayer sucks")
-            end
-          end
-        end
-      end
     end
 
     context "Exception mapping" do
@@ -1306,133 +1029,8 @@ describe ExceptionHandling do
         ExceptionHandling.log_error(exception, nil, honeybadger_tags: ["some-other-tag"])
       end
     end
-
-    describe "#add_honeybadger_tag_from_log_context" do
-      subject(:add_hb_tag) { ExceptionHandling.add_honeybadger_tag_from_log_context(tag_name, path: path) }
-      let(:tag_name) { "sample-tag" }
-      let(:path) { ["sample", "path"] }
-
-      it "sets the honeybadger log context tags to the tag name and path" do
-        add_hb_tag
-        expect(ExceptionHandling.honeybadger_log_context_tags).to include("sample-tag" => ["sample", "path"])
-      end
-
-      context "when path is not an array" do
-        let(:path) { "not an array" }
-
-        it "raises an argument error" do
-          expect { add_hb_tag }.to raise_error(ArgumentError, /path must be an Array/)
-        end
-      end
-
-      context "when tag_name is not a string" do
-        let(:tag_name) { 1 }
-
-        it "raises an argument error" do
-          expect { add_hb_tag }.to raise_error(ArgumentError, /tag_name must be a String/)
-        end
-      end
-
-      context "when there already exists a tag with the same name" do
-        before(:each) do
-          ExceptionHandling.add_honeybadger_tag_from_log_context(tag_name, path: ["other", "path"])
-        end
-
-        it "overwrites the existing tag to the new one" do
-          add_hb_tag
-          expect(ExceptionHandling.honeybadger_log_context_tags).to include("sample-tag" => ["sample", "path"])
-        end
-
-        it "logs a warning" do
-          expect(ExceptionHandling.logger).to receive(:warn).with(/Overwriting existing tag path for 'sample-tag'/, **{})
-          add_hb_tag
-        end
-      end
-    end
-
-    describe "honey badger tags" do
-      context "with log context tags" do
-        before(:each) do
-          ExceptionHandling.add_honeybadger_tag_from_log_context("kubernetes_context", path: ["kubernetes", "context"])
-        end
-
-        context "when error is logged within a log context that matches the path" do
-          it "notifies honeybadger with the tags from the log context" do
-            ExceptionHandling.logger.with_context("kubernetes" => { "context" => "local" }) do
-              expect(Honeybadger).to receive(:notify).with(hash_including({ tags: "kubernetes_context:local" }))
-              ExceptionHandling.log_error(StandardError.new("Error"), nil)
-            end
-          end
-        end
-
-        context "when error is logged within a log context that doesn't match the path" do
-          it "does not specify any tags in the honeybadger notify" do
-            ExceptionHandling.logger.with_context("kubernetes" => { "pod" => "frontend-abc" }) do
-              expect(Honeybadger).to receive(:notify).with(hash_including({ tags: "" }))
-              ExceptionHandling.log_error(StandardError.new("Error"), nil)
-            end
-          end
-        end
-
-        context "when error is logged outside of a log context block" do
-          it "does not specify any tags in the honeybadger notify" do
-            expect(Honeybadger).to receive(:notify).with(hash_including({ tags: "" }))
-            ExceptionHandling.log_error(StandardError.new("Error"), nil)
-          end
-        end
-      end
-
-      context "with all different honeybadger tagging" do
-        subject(:log_error) { ExceptionHandling.log_error(StandardError.new("Error"), nil, honeybadger_tags: inline_tags) }
-        let(:inline_tags) { ["inline-tag"] }
-        before(:each) do
-          ExceptionHandling.honeybadger_auto_tagger = ->(_exception) { ["auto-tag"] }
-          ExceptionHandling.add_honeybadger_tag_from_log_context("log-context", path: ["inside", "context"])
-        end
-
-        it "combines all the tags from different sources" do
-          expect(Honeybadger).to receive(:notify).with(hash_including({ tags: "auto-tag inline-tag log-context:tag" }))
-          ExceptionHandling.logger.with_context("inside" => { "context" => "tag" }) do
-            log_error
-          end
-        end
-
-        context "when there are duplicate tags" do
-          let(:inline_tags) { ["auto-tag"] }
-
-          it "notifies honeybadger with the set of tags" do
-            expect(Honeybadger).to receive(:notify).with(hash_including({ tags: "auto-tag log-context:tag" }))
-            ExceptionHandling.logger.with_context("inside" => { "context" => "tag" }) do
-              log_error
-            end
-          end
-        end
-      end
-    end
   end
 
-  context "ExceptionHandling < 3.0 " do
-    it "should return a deprecation warning" do
-      ExceptionHandling.production_support_recipients = "prodsupport@example.com"
-      expect { ExceptionHandling.escalate_to_production_support("blah", "invoca@example.com") }
-        .to output(/DEPRECATION WARNING: escalate_to_production_support is deprecated and will be removed from ExceptionHandling 3.0/).to_stderr
-    end
-
-    it "should return a deprecation warning" do
-      expect { ExceptionHandling.escalate_error("blah", "invoca@example.com") }
-        .to output(/DEPRECATION WARNING: escalate_error is deprecated and will be removed from ExceptionHandling 3.0/).to_stderr
-    end
-
-    it "should return a deprecation warning" do
-      expect { ExceptionHandling.escalate_warning("blah", "invoca@example.com") }
-        .to output(/DEPRECATION WARNING: escalate_warning is deprecated and will be removed from ExceptionHandling 3.0/).to_stderr
-    end
-
-    it "should return a deprecation warning" do
-      expect { ExceptionHandling.ensure_escalation("blah", "invoca@example.com") }
-        .to output(/DEPRECATION WARNING: ensure_escalation is deprecated and will be removed from ExceptionHandling 3.0/).to_stderr
-    end
-  end
 
   private
 

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: exception_handling
 version: !ruby/object:Gem::Version
-  version: 2.17.0.pre.tstarck.1
+  version: 3.0.0.pre.2
 platform: ruby
 authors:
 - Invoca
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-09 00:00:00.000000000 Z
+date: 2024-02-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: actionmailer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
-- !ruby/object:Gem::Dependency
-  name: actionpack
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
-- !ruby/object:Gem::Dependency
-  name: eventmachine
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: invoca-utils
   requirement: !ruby/object:Gem::Requirement
@@ -122,21 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: net-smtp
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Exception handling logger/emailer
+description: Exception handling logger
 email:
 - development@invoca.com
 executables: []
@@ -169,9 +113,6 @@ files:
 - lib/exception_handling/exception_info.rb
 - lib/exception_handling/log_stub_error.rb
 - lib/exception_handling/logging_methods.rb
-- lib/exception_handling/mailer.rb
-- lib/exception_handling/methods.rb
-- lib/exception_handling/sensu.rb
 - lib/exception_handling/testing.rb
 - lib/exception_handling/version.rb
 - spec/helpers/controller_helpers.rb
@@ -184,13 +125,7 @@ files:
 - spec/unit/exception_handling/exception_info_spec.rb
 - spec/unit/exception_handling/log_error_stub_spec.rb
 - spec/unit/exception_handling/logging_methods_spec.rb
-- spec/unit/exception_handling/mailer_spec.rb
-- spec/unit/exception_handling/methods_spec.rb
-- spec/unit/exception_handling/sensu_spec.rb
 - spec/unit/exception_handling_spec.rb
-- views/exception_handling/mailer/escalate_custom.html.erb
-- views/exception_handling/mailer/escalation_notification.html.erb
-- views/exception_handling/mailer/log_parser_exception_notification.html.erb
 homepage: https://github.com/Invoca/exception_handling
 licenses: []
 metadata:
@@ -204,18 +139,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
-summary: Invoca's exception handling logger/emailer layer, based on exception_notifier.
-  Works with Rails or EventMachine or EventMachine+Synchrony.
+summary: Invoca's exception handling logger layer, based on exception_notifier.
 test_files:
 - spec/helpers/controller_helpers.rb
 - spec/helpers/exception_helpers.rb
@@ -227,7 +161,4 @@ test_files:
 - spec/unit/exception_handling/exception_info_spec.rb
 - spec/unit/exception_handling/log_error_stub_spec.rb
 - spec/unit/exception_handling/logging_methods_spec.rb
-- spec/unit/exception_handling/mailer_spec.rb
-- spec/unit/exception_handling/methods_spec.rb
-- spec/unit/exception_handling/sensu_spec.rb
 - spec/unit/exception_handling_spec.rb