errorgap 0.8.0 → 0.10.0

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/sanitizer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Errorgap
+  # Makes caller-supplied data safe to serialize: masks sensitive keys at any
+  # depth, cuts long strings and large or deeply nested collections, replaces
+  # invalid UTF-8 and breaks reference cycles. Without it one binary param or
+  # a self-referencing hash loses the whole notice.
+  class Sanitizer
+    FILTERED = "[FILTERED]"
+    TRUNCATED = "[TRUNCATED]"
+    CIRCULAR = "[CIRCULAR]"
+    MAX_STRING = 4096
+    MAX_ITEMS = 128
+    MAX_DEPTH = 8
+
+    # `filter_keys` entries are substrings (case-insensitive) or Regexps.
+    def initialize(filter_keys = [])
+      @filter_keys = Array(filter_keys).map { |key| key.is_a?(Regexp) ? key : key.to_s.downcase }
+    end
+
+    # Truncate only.
+    def clean(value)
+      walk(value, false, 0, {})
+    end
+
+    # Truncate and mask sensitive keys.
+    def filter(value)
+      walk(value, true, 0, {})
+    end
+
+    def self.string(value, limit = MAX_STRING)
+      text = value.to_s
+      text = text.dup.force_encoding(Encoding::UTF_8) unless text.encoding == Encoding::UTF_8
+      text = text.scrub("?") unless text.valid_encoding?
+      text.length > limit ? "#{text[0, limit]}#{TRUNCATED}" : text
+    rescue StandardError
+      "[UNPRINTABLE]"
+    end
+
+    private
+
+    def walk(value, masking, depth, seen)
+      case value
+      when Hash
+        nested(value, depth, seen) do
+          value.first(MAX_ITEMS).each_with_object({}) do |(key, item), result|
+            name = self.class.string(key, 256)
+            result[name] = masking && sensitive?(name) ? FILTERED : walk(item, masking, depth + 1, seen)
+          end
+        end
+      when Array
+        nested(value, depth, seen) do
+          value.first(MAX_ITEMS).map { |item| walk(item, masking, depth + 1, seen) }
+        end
+      when String, Symbol
+        self.class.string(value)
+      when Integer, NilClass, TrueClass, FalseClass
+        value
+      when Float
+        value.finite? ? value : value.to_s
+      else
+        if value.respond_to?(:to_hash)
+          walk(value.to_hash, masking, depth, seen)
+        else
+          self.class.string(value)
+        end
+      end
+    rescue StandardError
+      "[UNPRINTABLE]"
+    end
+
+    def nested(value, depth, seen)
+      return TRUNCATED if depth >= MAX_DEPTH
+      return CIRCULAR if seen[value.object_id]
+
+      seen[value.object_id] = true
+      begin
+        yield
+      ensure
+        seen.delete(value.object_id)
+      end
+    end
+
+    def sensitive?(key)
+      lowered = key.downcase
+      @filter_keys.any? do |filter|
+        filter.is_a?(Regexp) ? filter.match?(key) : lowered.include?(filter)
+      end
+    end
+  end
+end

data/lib/errorgap/sign_ins.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
 require "time"
 
 module Errorgap
@@ -53,27 +50,13 @@ module Errorgap
       if sync || !@configuration.async
         deliver(payload)
       else
-        Errorgap.register_thread(Thread.new { deliver(payload) })
+        Errorgap.delivery.enqueue("logins/web", payload)
         nil
       end
     end
 
     def deliver(payload)
-      uri = URI.join(
-        @configuration.endpoint.end_with?("/") ? @configuration.endpoint : "#{@configuration.endpoint}/",
-        "api/projects/#{@configuration.project_slug}/logins/web"
-      )
-      request = Net::HTTP::Post.new(uri)
-      request["Content-Type"] = "application/json"
-      request["User-Agent"] = "errorgap-ruby/#{Errorgap::VERSION}"
-      request["X-Errorgap-Project-Key"] = @configuration.api_key if present?(@configuration.api_key)
-      request.body = JSON.generate(payload)
-
-      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(request)
-      end
-    rescue StandardError => exception
-      @configuration.logger&.warn("[errorgap] sign-in delivery error: #{exception.class}: #{exception.message}")
+      Errorgap.delivery.post("logins/web", payload)
     end
 
     private

data/lib/errorgap/transacter.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
-
 module Errorgap
   class Transacter
     def initialize(configuration)
@@ -16,27 +12,14 @@ module Errorgap
 
     def deliver_async(transaction)
       return if @configuration.ignored_environment?
+      return unless Errorgap.remote_settings.enabled?(:apm)
       return unless should_sample?
 
-      Errorgap.register_thread(Thread.new { deliver(transaction) })
+      Errorgap.delivery.enqueue("transactions", transaction.to_h)
     end
 
     def deliver(transaction)
-      uri = URI.join(
-        @configuration.endpoint.end_with?("/") ? @configuration.endpoint : "#{@configuration.endpoint}/",
-        "api/projects/#{@configuration.project_slug}/transactions"
-      )
-      request = Net::HTTP::Post.new(uri)
-      request["Content-Type"] = "application/json"
-      request["User-Agent"] = "errorgap-ruby/#{Errorgap::VERSION}"
-      request["X-Errorgap-Project-Key"] = @configuration.api_key if present?(@configuration.api_key)
-      request.body = JSON.generate(transaction.to_h)
-
-      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(request)
-      end
-    rescue StandardError => exception
-      @configuration.logger&.warn("[errorgap] APM delivery error: #{exception.class}: #{exception.message}")
+      Errorgap.delivery.post("transactions", transaction.to_h)
     end
 
     private
@@ -48,9 +31,5 @@ module Errorgap
 
       rand < rate
     end
-
-    def present?(value)
-      !value.nil? && !value.to_s.empty?
-    end
   end
 end

data/lib/errorgap/version.rb

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

data/lib/errorgap.rb

@@ -3,6 +3,10 @@
 require "securerandom"
 
 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"
@@ -14,12 +18,20 @@ require_relative "errorgap/span_collector"
 require_relative "errorgap/span_recorder"
 require_relative "errorgap/transacter"
 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
   class << self
     def configure
       yield(configuration)
+      delivery.configure(configuration)
+      remote_settings.configure(configuration)
       notifier.configure(configuration)
       transacter.configure(configuration)
       log_delivery.configure(configuration)
@@ -35,6 +47,16 @@ 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)
+    end
+
     def transacter
       @transacter ||= Transacter.new(configuration)
     end
@@ -65,6 +87,7 @@ module Errorgap
       if (transaction_id = current_transaction_id) && !context.key?(:transaction_id) && !context.key?("transaction_id")
         context = context.merge(transaction_id: transaction_id)
       end
+      session = user_session.merge(session || {}) if current_user
       notifier.notify(
         error,
         context: context,
@@ -76,6 +99,82 @@ module Errorgap
       )
     end
 
+    REPORTED_IVAR = :@__errorgap_reported
+    USER_KEY = :errorgap_user
+
+    # `notify`, unless this exception object was already reported: lets the
+    # Rack middleware, a job integration and the app's own rescue all see the
+    # same error without sending it more than once.
+    def notify_once(error, **options)
+      return nil if reported?(error)
+
+      mark_reported(error)
+      notify(error, **options)
+    end
+
+    def reported?(error)
+      error.instance_variable_defined?(REPORTED_IVAR)
+    rescue StandardError
+      false
+    end
+
+    def mark_reported(error)
+      error.instance_variable_set(REPORTED_IVAR, true) unless error.frozen?
+    rescue StandardError
+      nil
+    end
+
+    # Name the user the current request or job is acting for. Errors reported
+    # on this thread until `clear_user` carry it as `session.user_id` /
+    # `session.user_email`, which errorgap's user filters read.
+    def set_user(id: nil, email: nil)
+      user = {}
+      user[:id] = id.to_s unless id.nil? || id.to_s.empty?
+      user[:email] = email.to_s unless email.nil? || email.to_s.empty?
+      Thread.current[USER_KEY] = user.empty? ? nil : user
+    end
+
+    def clear_user
+      Thread.current[USER_KEY] = nil
+    end
+
+    def current_user
+      Thread.current[USER_KEY]
+    end
+
+    # Record a release with errorgap (Deploys): errors are then attributed to
+    # the deploy that shipped them. Defaults come from the configuration.
+    def track_release(version: nil, sha: nil, branch: nil, environment: nil, sync: true)
+      configuration.validate!
+      return if configuration.ignored_environment?
+
+      payload = {
+        version: version || configuration.release,
+        sha: sha || configuration.release_sha,
+        branch: branch || configuration.release_branch,
+        environment: environment || configuration.environment
+      }.compact
+      return unless payload[:version] || payload[:sha]
+
+      if sync
+        delivery.post("releases", payload)
+      else
+        delivery.enqueue("releases", payload)
+      end
+    rescue StandardError => exception
+      configuration.logger&.warn("[errorgap] release not recorded: #{exception.class}: #{exception.message}")
+      nil
+    end
+
+    # `config.track_release`: the first notice of a process records the
+    # release, so an app that never errors never calls errorgap.
+    def record_release_once
+      return if @release_recorded
+
+      @release_recorded = true
+      track_release(sync: false)
+    end
+
     # Record a diagnostic breadcrumb attached to subsequent notices.
     def add_breadcrumb(message, category: nil, metadata: nil)
       breadcrumbs.add(message, category: category, metadata: metadata)
@@ -121,12 +220,13 @@ 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
         transacter.deliver(transaction)
       else
-        register_thread(Thread.new { transacter.deliver(transaction) })
+        delivery.enqueue("transactions", transaction.to_h)
       end
     end
 
@@ -176,25 +276,38 @@ module Errorgap
       end
     end
 
-    # Join any in-flight async delivery threads. Call before process exit to
-    # avoid dropping queued notices/transactions/logs.
-    def flush
+    # Wait for queued notices, transactions and logs to be sent. Call before
+    # process exit; queued payloads are also flushed from an `at_exit` hook.
+    def flush(timeout = Delivery::FLUSH_TIMEOUT)
+      delivery.flush(timeout)
       threads = thread_mutex.synchronize do
         pending = delivery_threads.dup
         delivery_threads.clear
         pending
       end
-      threads.each { |thread| thread.join(5) }
+      threads.each { |thread| thread.join(timeout) }
       nil
     end
 
+    # Kept for callers that run their own delivery threads.
     def register_thread(thread)
-      thread_mutex.synchronize { delivery_threads << thread }
+      thread_mutex.synchronize do
+        delivery_threads.select!(&:alive?)
+        delivery_threads << thread
+      end
       thread
     end
 
     private
 
+    def user_session
+      user = current_user || {}
+      session = {}
+      session["user_id"] = user[:id] if user[:id]
+      session["user_email"] = user[:email] if user[:email]
+      session
+    end
+
     def sample_apm?
       rate = configuration.apm_sample_rate.to_f
       return true if rate >= 1.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: errorgap
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Errorgap
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-06 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -67,11 +67,21 @@ files:
 - lib/errorgap.rb
 - lib/errorgap/breadcrumbs.rb
 - 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
 - lib/errorgap/notifier.rb
 - 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
 - lib/errorgap/span_recorder.rb