errorgap 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c01da4468e72e4df60f1a720efa5f8c5873357a2681c3c8163b97c83de0489f4
-  data.tar.gz: 11274b3058d605600c50fcac50f3e9dc7e9f118d5f8d1ab673d6b754d3e039d6
+  metadata.gz: f52bfa8726abcfbc207b98bc4756db649a619595a56298d4c06b73c63d7b8d08
+  data.tar.gz: bf7d11b852e1fffe27e928ccc259fa3589d35997e4d4eeabfa609c19020a16f6
 SHA512:
-  metadata.gz: 0b438eac927e6e9fe023551f5106b73a4f4e160af91acc90940686fbae4924ba33216ff524d224145c23370cdc398b47bfac644920c28a9edeab8c4e2a29a201
-  data.tar.gz: 521300e7615cce7765d24e98563368815b2cd7d6cb8397205988b3bcd2673d378bd14bad26ec5845d87dd20cc639b882fc865e4699efe287dee5dc078f76a93d
+  metadata.gz: 32f5f975ae8555dc20ee6cdde6618ebe5b001ecf89b51bb59e4f4b72cd3a2d64747c5814c60ab590fe26adbfb23f5923dd2c45511c2c22ad4c3b518877917368
+  data.tar.gz: 7aec10caf7eef47f0e593266cfe554ef67aab2c2fb32e03320cfd3e7c1fad88db40b9ececff9241dbb136858c3f85830fe895b6dc6442d789b474cf8c19252bd

data/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.10.0] - 2026-10-13
+
+### Added
+
+- **Remote settings.** The gem follows the project's settings in errorgap
+  (Project settings › What SDKs send): when errors, performance data or logs
+  are switched off there, running apps stop sending them within ten minutes,
+  with no deploy. Read on a background thread from
+  `GET /api/projects/:slug/config`; if errorgap cannot be reached everything
+  stays on. `config.remote_settings = false` (or
+  `ERRORGAP_REMOTE_SETTINGS=false`) turns this off.
+- **Resque.** Failed jobs are reported with their class, queue and arguments,
+  alongside Resque's own failure backend.
+- **Delayed Job.** Jobs are timed as `job` transactions and their errors
+  reported with the job class, queue, id and attempt count.
+- **Rake.** An error that ends a task is reported with the task's name and
+  flushed before Rake exits.
+
+In Rails all three are installed for you. Elsewhere:
+`Errorgap::Integrations::Resque.install`, `…::DelayedJob.install`,
+`…::Rake.install`.
+
 ## [0.9.0] - 2026-10-13
 
 ### Added

data/README.md

@@ -62,6 +62,18 @@ Errorgap::Integrations::ActiveJob.install
 Errorgap::Integrations::Sidekiq.install
 ```
 
+Resque, Delayed Job and Rake tasks are covered the same way (in Rails with no
+setup; elsewhere `Errorgap::Integrations::Resque.install`,
+`Errorgap::Integrations::DelayedJob.install`,
+`Errorgap::Integrations::Rake.install`).
+
+## Remote settings
+
+Errors, performance data and logs can each be switched off for a project in
+errorgap (Project settings › What SDKs send). Running apps follow within ten
+minutes, with no deploy. If errorgap cannot be reached, everything stays on.
+`config.remote_settings = false` ignores the project's switches.
+
 ## Users
 
 Errors raised in a request carry the signed-in Warden / Devise user's id and

data/lib/errorgap/configuration.rb

@@ -23,6 +23,7 @@ module Errorgap
                   :track_release,
                   :release_sha,
                   :release_branch,
+                  :remote_settings,
                   :auth_events,
                   :auth_user,
                   :app_name
@@ -62,6 +63,10 @@ module Errorgap
       # request (Warden / Devise).
       @capture_user = true
       @before_notify_hooks = []
+      # Follow the project's settings in errorgap (Project settings › What
+      # SDKs send): stop sending errors, performance data or logs when they
+      # are switched off there.
+      @remote_settings = ENV["ERRORGAP_REMOTE_SETTINGS"].to_s.strip.downcase != "false"
       # Sign-ins to this app (Security › Logins). Off until you opt in: they
       # carry user names and IPs.
       @auth_events = false

data/lib/errorgap/integrations/delayed_job.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Errorgap
+  module Integrations
+    # Delayed Job: every job runs as a `job` transaction and an error it
+    # raises is reported with the job's class, queue, id and attempt count,
+    # then re-raised so Delayed Job's retries work as before.
+    #
+    #   Errorgap::Integrations::DelayedJob.install   # after Delayed Job is loaded
+    module DelayedJob
+      ACTIVE_JOB_WRAPPER = "ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper"
+
+      class << self
+        def install
+          return false unless defined?(::Delayed::Plugin) && defined?(::Delayed::Worker)
+          return true if @installed
+
+          ::Delayed::Worker.plugins << plugin
+          @installed = true
+        end
+
+        def plugin
+          @plugin ||= Class.new(::Delayed::Plugin) do
+            callbacks do |lifecycle|
+              lifecycle.around(:invoke_job) do |job, *args, &block|
+                Errorgap::Integrations::DelayedJob.invoke(job) { block.call(job, *args) }
+              end
+            end
+          end
+        end
+
+        def invoke(job, &block)
+          job_class = job_name(job)
+          # An ActiveJob run by Delayed Job is covered by the ActiveJob
+          # integration, which knows the real job class and its arguments.
+          return yield if job_class == ACTIVE_JOB_WRAPPER && ActiveJob.installed?
+
+          Errorgap.track_job(job_class, queue: (job.respond_to?(:queue) && job.queue) || "default") do
+            run(job, job_class, &block)
+          end
+        ensure
+          Errorgap.clear_user
+        end
+
+        private
+
+        def run(job, job_class)
+          yield
+        rescue Exception => exception # rubocop:disable Lint/RescueException
+          Errorgap.notify_once(
+            exception,
+            context: { component: "delayed_job", action: job_class },
+            environment: {
+              queue: job.respond_to?(:queue) ? job.queue : nil,
+              job_id: job.respond_to?(:id) ? job.id : nil,
+              attempts: job.respond_to?(:attempts) ? job.attempts : nil
+            }.compact
+          )
+          raise
+        end
+
+        # `Mailer.delay.welcome(user)` is a PerformableMethod: name it by
+        # what it calls rather than by the wrapper.
+        def job_name(job)
+          payload = job.payload_object
+          return payload.display_name.to_s if payload.respond_to?(:display_name)
+
+          payload.class.name.to_s
+        rescue StandardError
+          "Delayed::Job"
+        end
+      end
+    end
+  end
+end

data/lib/errorgap/integrations/rake.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Errorgap
+  module Integrations
+    # Rake: report an error that ends a task, with the task's name, then
+    # re-raise it. The report is flushed before Rake exits.
+    #
+    #   require "errorgap"
+    #   Errorgap::Integrations::Rake.install   # in the Rakefile
+    #
+    # In Rails this is installed for you.
+    module Rake
+      class << self
+        def install
+          return false unless defined?(::Rake::Task)
+          return true if @installed
+
+          ::Rake::Task.prepend(Patch)
+          @installed = true
+        end
+      end
+
+      module Patch
+        def execute(args = nil)
+          super
+        rescue SystemExit, Interrupt
+          raise
+        rescue Exception => exception # rubocop:disable Lint/RescueException
+          begin
+            Errorgap.notify_once(
+              exception,
+              context: { component: "rake", action: name.to_s },
+              params: { "arguments" => args.respond_to?(:to_a) ? args.to_a : nil }
+            )
+            Errorgap.flush
+          rescue StandardError
+            nil
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/errorgap/integrations/resque.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Errorgap
+  module Integrations
+    # Resque: report failed jobs with their class, queue and arguments.
+    # Resque's own failure backend (the Failed tab) keeps working alongside.
+    #
+    #   Errorgap::Integrations::Resque.install   # after Resque is loaded
+    module Resque
+      class << self
+        def install
+          return false unless defined?(::Resque::Failure::Base)
+          return true if @installed
+
+          require "resque/failure/multiple"
+          current = ::Resque::Failure.backend
+          backends = current == ::Resque::Failure::Multiple ? ::Resque::Failure::Multiple.classes : [current]
+          ::Resque::Failure::Multiple.classes = (backends + [backend]).uniq
+          ::Resque::Failure.backend = ::Resque::Failure::Multiple
+          @installed = true
+        end
+
+        # The failure backend, defined on first use so loading errorgap does
+        # not need Resque.
+        def backend
+          @backend ||= Class.new(::Resque::Failure::Base) do
+            def save
+              job_class = payload.is_a?(Hash) ? payload["class"].to_s : ""
+              Errorgap.notify_once(
+                exception,
+                context: { component: "resque", action: job_class },
+                environment: { queue: queue.to_s },
+                params: { "arguments" => payload.is_a?(Hash) ? payload["args"] : nil }
+              )
+            end
+
+            def self.count(*)
+              0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/errorgap/log_delivery.rb

@@ -21,6 +21,7 @@ module Errorgap
     def log(message, level: "info", source: nil, environment: nil, occurred_at: nil, sync: false)
       return unless @configuration.logs_enabled
       return if @configuration.ignored_environment?
+      return unless Errorgap.remote_settings.enabled?(:logs)
 
       normalized = self.class.normalize_level(level)
       return if self.class.rank(normalized) < self.class.rank(self.class.normalize_level(@configuration.minimum_log_level))

data/lib/errorgap/notifier.rb

@@ -19,6 +19,9 @@ module Errorgap
     def notify(error, context: {}, environment: {}, session: {}, params: {}, breadcrumbs: [], sync: false)
       @configuration.validate!
       return Response.new(status: 202, body: "ignored environment") if @configuration.ignored_environment?
+      unless Errorgap.remote_settings.enabled?(:errors)
+        return Response.new(status: 202, body: "errors are switched off for this project")
+      end
 
       notice = Notice.from_exception(
         error,

data/lib/errorgap/rails/railtie.rb

@@ -31,6 +31,13 @@ module Errorgap
       initializer "errorgap.install_job_integrations" do
         Errorgap::Integrations::ActiveJob.install
         Errorgap::Integrations::Sidekiq.install
+        Errorgap::Integrations::Resque.install
+        Errorgap::Integrations::DelayedJob.install
+      end
+
+      # `rails some:task` / `rake some:task` errors.
+      rake_tasks do
+        Errorgap::Integrations::Rake.install
       end
 
       # After config/initializers, so `auth_events` is readable here.

data/lib/errorgap/remote_settings.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Errorgap
+  # The project's remote settings: what errorgap wants this app to send.
+  # Someone can turn errors, performance data or logs off for a project in
+  # errorgap (Project settings › What SDKs send) and running apps follow
+  # within a poll interval, with no deploy.
+  #
+  # Read from `GET /api/projects/:slug/config` on a background thread, never
+  # on the caller's. Until the first answer, and whenever errorgap cannot be
+  # reached, everything stays on.
+  class RemoteSettings
+    DEFAULT_INTERVAL = 600
+    MIN_INTERVAL = 60
+    KINDS = { errors: "errors_enabled", apm: "apm_enabled", logs: "logs_enabled" }.freeze
+
+    def initialize(configuration)
+      @configuration = configuration
+      @mutex = Mutex.new
+      @settings = {}
+      @interval = DEFAULT_INTERVAL
+      @thread = nil
+      @pid = nil
+    end
+
+    def configure(configuration)
+      @configuration = configuration
+    end
+
+    # False only when errorgap has said to stop sending this kind of data.
+    def enabled?(kind)
+      return true unless @configuration.remote_settings
+
+      ensure_polling
+      @settings[KINDS.fetch(kind)] != false
+    end
+
+    # Fetch now, on this thread. Returns the settings, or nil when they
+    # could not be read.
+    def refresh
+      uri = URI.join(base_url, "api/projects/#{@configuration.project_slug}/config")
+      request = Net::HTTP::Get.new(uri)
+      request["User-Agent"] = "errorgap-ruby/#{Errorgap::VERSION}"
+      request["X-Errorgap-Project-Key"] = @configuration.api_key.to_s unless @configuration.api_key.to_s.empty?
+      timeout = @configuration.timeout.to_f.positive? ? @configuration.timeout.to_f : 5
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https",
+                                                         open_timeout: timeout, read_timeout: timeout) do |http|
+        http.request(request)
+      end
+      return nil unless response.code.to_i == 200
+
+      apply(JSON.parse(response.body))
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    def apply(body)
+      return nil unless body.is_a?(Hash)
+
+      @settings = body.slice(*KINDS.values)
+      seconds = body["poll_interval_seconds"].to_i
+      @interval = seconds >= MIN_INTERVAL ? seconds : DEFAULT_INTERVAL
+      @settings
+    end
+
+    # A forked child (Puma workers, Sidekiq) has the settings but not the
+    # thread: start its own.
+    def ensure_polling
+      return if @pid == Process.pid && @thread&.alive?
+      return if @configuration.project_slug.to_s.strip.empty?
+
+      @mutex.synchronize do
+        return if @pid == Process.pid && @thread&.alive?
+
+        @pid = Process.pid
+        @thread = Thread.new do
+          loop do
+            Thread.current[:errorgap_sending] = true
+            refresh
+            sleep(@interval)
+          end
+        end
+        @thread.name = "errorgap-settings" if @thread.respond_to?(:name=)
+        @thread.report_on_exception = false if @thread.respond_to?(:report_on_exception=)
+      end
+    end
+
+    def base_url
+      endpoint = @configuration.endpoint.to_s
+      endpoint.end_with?("/") ? endpoint : "#{endpoint}/"
+    end
+  end
+end

data/lib/errorgap/transacter.rb

@@ -12,6 +12,7 @@ module Errorgap
 
     def deliver_async(transaction)
       return if @configuration.ignored_environment?
+      return unless Errorgap.remote_settings.enabled?(:apm)
       return unless should_sample?
 
       Errorgap.delivery.enqueue("transactions", transaction.to_h)

data/lib/errorgap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Errorgap
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/errorgap.rb

@@ -6,6 +6,7 @@ require_relative "errorgap/configuration"
 require_relative "errorgap/sanitizer"
 require_relative "errorgap/release_detector"
 require_relative "errorgap/delivery"
+require_relative "errorgap/remote_settings"
 require_relative "errorgap/breadcrumbs"
 require_relative "errorgap/notifier"
 require_relative "errorgap/notice"
@@ -20,6 +21,9 @@ require_relative "errorgap/rack_middleware"
 require_relative "errorgap/integrations/sidekiq"
 require_relative "errorgap/integrations/active_job"
 require_relative "errorgap/integrations/net_http"
+require_relative "errorgap/integrations/resque"
+require_relative "errorgap/integrations/delayed_job"
+require_relative "errorgap/integrations/rake"
 require_relative "errorgap/version"
 
 module Errorgap
@@ -27,6 +31,7 @@ module Errorgap
     def configure
       yield(configuration)
       delivery.configure(configuration)
+      remote_settings.configure(configuration)
       notifier.configure(configuration)
       transacter.configure(configuration)
       log_delivery.configure(configuration)
@@ -42,6 +47,11 @@ module Errorgap
       @notifier ||= Notifier.new(configuration)
     end
 
+    # What errorgap wants this app to send (the project's remote settings).
+    def remote_settings
+      @remote_settings ||= RemoteSettings.new(configuration)
+    end
+
     # The shared sender behind notices, transactions, logs and sign-ins.
     def delivery
       @delivery ||= Delivery.new(configuration)
@@ -210,6 +220,7 @@ module Errorgap
     def notify_transaction(transaction, sync: false)
       return unless configuration.apm_enabled
       return if configuration.ignored_environment?
+      return unless remote_settings.enabled?(:apm)
       return unless sample_apm?
 
       if sync || !configuration.async

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: errorgap
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Errorgap
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-13 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -69,7 +69,10 @@ files:
 - lib/errorgap/configuration.rb
 - lib/errorgap/delivery.rb
 - lib/errorgap/integrations/active_job.rb
+- lib/errorgap/integrations/delayed_job.rb
 - lib/errorgap/integrations/net_http.rb
+- lib/errorgap/integrations/rake.rb
+- lib/errorgap/integrations/resque.rb
 - lib/errorgap/integrations/sidekiq.rb
 - lib/errorgap/log_delivery.rb
 - lib/errorgap/notice.rb
@@ -77,6 +80,7 @@ files:
 - lib/errorgap/rack_middleware.rb
 - lib/errorgap/rails/railtie.rb
 - lib/errorgap/release_detector.rb
+- lib/errorgap/remote_settings.rb
 - lib/errorgap/sanitizer.rb
 - lib/errorgap/sign_ins.rb
 - lib/errorgap/span_collector.rb