errorgap 0.8.0 → 0.9.0

data/lib/errorgap/notice.rb

@@ -11,6 +11,7 @@ module Errorgap
     MAX_SOURCE_FRAMES = 25
     MAX_SOURCE_LINE_LENGTH = 400
     MAX_CAUSE_DEPTH = 10
+    MAX_MESSAGE_LENGTH = 8192
 
     def self.from_exception(error, configuration:, context: {}, environment: {}, session: {}, params: {}, breadcrumbs: [])
       new(
@@ -40,15 +41,15 @@ module Errorgap
         received_at: Time.now.utc.iso8601,
         errors: [
           {
-            type: @error.class.name,
-            message: @error.message.to_s,
+            type: @error.class.name.to_s,
+            message: Sanitizer.string(@error.message, MAX_MESSAGE_LENGTH),
             backtrace: backtrace_frames
           }
         ],
-        context: default_context.merge(stringify_hash(@context)),
-        environment: stringify_hash(@environment),
-        session: stringify_hash(@session),
-        params: filter_hash(@params)
+        context: default_context.merge(sanitizer.clean(@context)),
+        environment: sanitizer.clean(@environment),
+        session: sanitizer.filter(@session),
+        params: sanitizer.filter(@params)
       }
     end
 
@@ -100,7 +101,7 @@ module Errorgap
     # The causes beyond the root error, as {type, message} pairs.
     def collect_causes
       error_chain.drop(1).map do |link|
-        { type: link.class.name, message: link.message.to_s }
+        { type: link.class.name.to_s, message: Sanitizer.string(link.message, MAX_MESSAGE_LENGTH) }
       end
     end
 
@@ -173,20 +174,8 @@ module Errorgap
       absolute_path.sub(%r{\A#{Regexp.escape(root)}/?}, "")
     end
 
-    def filter_hash(hash)
-      stringify_hash(hash).each_with_object({}) do |(key, value), filtered|
-        filtered[key] = sensitive?(key) ? "[FILTERED]" : value
-      end
-    end
-
-    def sensitive?(key)
-      @configuration.filter_keys.any? { |filter| key.to_s.downcase.include?(filter.downcase) }
-    end
-
-    def stringify_hash(hash)
-      hash.each_with_object({}) do |(key, value), result|
-        result[key.to_s] = value.is_a?(Hash) ? stringify_hash(value) : value
-      end
+    def sanitizer
+      @sanitizer ||= Sanitizer.new(@configuration.filter_keys)
     end
   end
 end

data/lib/errorgap/notifier.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
-
 module Errorgap
   class Notifier
     Response = Struct.new(:status, :body, :error, keyword_init: true) do
@@ -33,11 +29,15 @@ module Errorgap
         params: params,
         breadcrumbs: breadcrumbs
       )
+      payload = run_hooks(notice.to_h)
+      return Response.new(status: 202, body: "dropped by before_notify") unless payload
+
+      Errorgap.record_release_once if @configuration.track_release
 
       if sync || !@configuration.async
-        deliver(notice)
+        deliver(payload)
       else
-        Errorgap.register_thread(Thread.new { deliver(notice) })
+        Errorgap.delivery.enqueue("notices", payload)
         Response.new(status: 202, body: "queued")
       end
     rescue StandardError => exception
@@ -45,18 +45,11 @@ module Errorgap
       Response.new(error: exception)
     end
 
+    # `notice` is a Notice or an already built payload Hash.
     def deliver(notice)
-      uri = URI.join(@configuration.endpoint.end_with?("/") ? @configuration.endpoint : "#{@configuration.endpoint}/", "api/projects/#{@configuration.project_slug}/notices")
-      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(notice.to_h)
-
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(request)
-      end
-      Response.new(status: response.code.to_i, body: response.body)
+      payload = notice.respond_to?(:to_h) && !notice.is_a?(Hash) ? notice.to_h : notice
+      result = Errorgap.delivery.post("notices", payload)
+      Response.new(status: result.status, body: result.body, error: result.error)
     rescue StandardError => exception
       log(exception)
       Response.new(error: exception)
@@ -64,12 +57,25 @@ module Errorgap
 
     private
 
-    def log(exception)
-      @configuration.logger&.warn("[errorgap] #{exception.class}: #{exception.message}")
+    # A hook that raises is logged and skipped: a bug in a filter must not
+    # lose the error it was filtering.
+    def run_hooks(payload)
+      @configuration.before_notify_hooks.each do |hook|
+        begin
+          result = hook.call(payload)
+        rescue StandardError => exception
+          log(exception)
+          next
+        end
+        return nil if result == false
+
+        payload = result if result.is_a?(Hash) && result.key?(:errors)
+      end
+      payload
     end
 
-    def present?(value)
-      !value.nil? && !value.to_s.empty?
+    def log(exception)
+      @configuration.logger&.warn("[errorgap] #{exception.class}: #{exception.message}")
     end
   end
 end

data/lib/errorgap/rack_middleware.rb

@@ -20,6 +20,7 @@ module Errorgap
           notify_once(env, exception)
           raise
         ensure
+          Errorgap.clear_user
           elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
           record_transaction(env, status || 500, elapsed_ms, transaction_id)
         end
@@ -33,6 +34,8 @@ module Errorgap
     rescue Exception => exception # rubocop:disable Lint/RescueException
       notify_once(env, exception)
       raise
+    ensure
+      Errorgap.clear_user
     end
 
     UUID = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/
@@ -85,18 +88,19 @@ module Errorgap
       env["PATH_INFO"]
     end
 
+    # Queued, not sent inline: a slow or unreachable errorgap must not add
+    # its timeout to a request that is already failing.
     def notify_once(env, exception)
       notified = env["errorgap.notified_exception_ids"] ||= {}
       return if notified[exception.object_id]
 
       notified[exception.object_id] = true
-      Errorgap.notify(
+      Errorgap.notify_once(
         exception,
         context: rack_context(env),
         environment: rack_environment(env),
         session: rack_session(env),
-        params: rack_params(env),
-        sync: true
+        params: rack_params(env)
       )
     end
 
@@ -112,15 +116,54 @@ module Errorgap
       {
         method: env["REQUEST_METHOD"],
         path: env["PATH_INFO"],
-        query_string: env["QUERY_STRING"],
+        query_string: filtered_query(env["QUERY_STRING"]),
         user_agent: env["HTTP_USER_AGENT"],
         remote_addr: env["REMOTE_ADDR"]
       }
     end
 
+    # `?token=abc` is as sensitive in the query string as it is in params.
+    def filtered_query(query)
+      return query if query.nil? || query.empty?
+
+      keys = Array(Errorgap.configuration.filter_keys)
+      query.split("&").map do |pair|
+        name, value = pair.split("=", 2)
+        sensitive = keys.any? do |key|
+          key.is_a?(Regexp) ? key.match?(name.to_s) : name.to_s.downcase.include?(key.to_s.downcase)
+        end
+        sensitive && value ? "#{name}=[FILTERED]" : pair
+      end.join("&")
+    rescue StandardError
+      nil
+    end
+
     def rack_session(env)
       session = env["rack.session"]
-      session.respond_to?(:to_hash) ? session.to_hash : {}
+      data = session.respond_to?(:to_hash) ? session.to_hash : {}
+      signed_in_user(env).merge(data)
+    rescue StandardError
+      {}
+    end
+
+    # The signed-in user (Warden / Devise), unless the app named one itself
+    # with `Errorgap.set_user`. Only looks at a user Warden already loaded:
+    # it never triggers authentication from inside error handling.
+    def signed_in_user(env)
+      return {} unless Errorgap.configuration.capture_user
+      return {} if Errorgap.current_user
+
+      warden = env["warden"]
+      return {} unless warden.respond_to?(:authenticated?) && warden.respond_to?(:user)
+      return {} unless warden.authenticated?
+
+      user = warden.user
+      found = {}
+      found["user_id"] = user.id.to_s if user.respond_to?(:id) && user.id
+      found["user_email"] = user.email.to_s if user.respond_to?(:email) && user.email
+      found
+    rescue StandardError
+      {}
     end
 
     def rack_params(env)

data/lib/errorgap/rails/railtie.rb

@@ -23,6 +23,14 @@ module Errorgap
         # subscribers no-op unless the middleware starts a per-request
         # collection, which does check the flag.
         SpanCollector.install
+        Errorgap::Integrations::NetHTTP.install
+      end
+
+      # Background jobs: report their errors and time them. Like the span
+      # collector these check the configuration when a job runs.
+      initializer "errorgap.install_job_integrations" do
+        Errorgap::Integrations::ActiveJob.install
+        Errorgap::Integrations::Sidekiq.install
       end
 
       # After config/initializers, so `auth_events` is readable here.

data/lib/errorgap/release_detector.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Errorgap
+  # Works out which commit is running when `config.release` is not set, so
+  # errors are attributed to a deploy without any setup: the commit variables
+  # hosting platforms export, Capistrano's REVISION file, then the checkout's
+  # `.git/HEAD`.
+  module ReleaseDetector
+    ENV_KEYS = %w[
+      SOURCE_VERSION HEROKU_SLUG_COMMIT HEROKU_BUILD_COMMIT RENDER_GIT_COMMIT
+      RAILWAY_GIT_COMMIT_SHA VERCEL_GIT_COMMIT_SHA KAMAL_VERSION GIT_COMMIT GIT_SHA
+    ].freeze
+
+    class << self
+      def detect(root_directory, env = ENV)
+        ENV_KEYS.each do |key|
+          value = env[key].to_s.strip
+          return value unless value.empty?
+        end
+        root = root_directory.to_s
+        return nil if root.empty?
+
+        revision_file(root) || git_head(root)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def revision_file(root)
+        path = File.join(root, "REVISION")
+        return nil unless File.file?(path)
+
+        value = File.read(path, 200).to_s.strip
+        value.empty? ? nil : value
+      end
+
+      def git_head(root)
+        git = File.join(root, ".git")
+        # A worktree or submodule has a `.git` file pointing at the real dir.
+        if File.file?(git)
+          pointer = File.read(git, 1024).to_s[/\Agitdir:\s*(.+)$/, 1]
+          return nil unless pointer
+
+          git = File.expand_path(pointer.strip, root)
+        end
+        head_path = File.join(git, "HEAD")
+        return nil unless File.file?(head_path)
+
+        head = File.read(head_path, 1024).to_s.strip
+        ref = head[/\Aref:\s*(.+)\z/, 1]
+        return sha(head) unless ref
+
+        ref_path = File.join(git, ref)
+        return sha(File.read(ref_path, 200).to_s.strip) if File.file?(ref_path)
+
+        packed = File.join(git, "packed-refs")
+        return nil unless File.file?(packed)
+
+        line = File.foreach(packed).find { |entry| entry.strip.end_with?(" #{ref}") }
+        line ? sha(line.split(" ").first) : nil
+      end
+
+      def sha(value)
+        value.to_s.match?(/\A\h{7,64}\z/) ? value : nil
+      end
+    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)
@@ -18,25 +14,11 @@ module Errorgap
       return if @configuration.ignored_environment?
       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 +30,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.9.0"
 end

data/lib/errorgap.rb

@@ -3,6 +3,9 @@
 require "securerandom"
 
 require_relative "errorgap/configuration"
+require_relative "errorgap/sanitizer"
+require_relative "errorgap/release_detector"
+require_relative "errorgap/delivery"
 require_relative "errorgap/breadcrumbs"
 require_relative "errorgap/notifier"
 require_relative "errorgap/notice"
@@ -14,12 +17,16 @@ 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/version"
 
 module Errorgap
   class << self
     def configure
       yield(configuration)
+      delivery.configure(configuration)
       notifier.configure(configuration)
       transacter.configure(configuration)
       log_delivery.configure(configuration)
@@ -35,6 +42,11 @@ module Errorgap
       @notifier ||= Notifier.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 +77,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 +89,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)
@@ -126,7 +215,7 @@ module Errorgap
       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 +265,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