errorgap 0.8.0 → 0.10.0

data/lib/errorgap/integrations/net_http.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Errorgap
+  module Integrations
+    # Times outbound `Net::HTTP` requests made during a transaction and
+    # records each as an `http` span named by method and host. Most Ruby HTTP
+    # clients (Faraday's default adapter, HTTParty, RestClient) use Net::HTTP
+    # underneath. Requests errorgap makes itself are left out.
+    module NetHTTP
+      class << self
+        def install
+          return false unless defined?(::Net::HTTP)
+          return true if @installed
+
+          ::Net::HTTP.prepend(Patch)
+          @installed = true
+        end
+      end
+
+      module Patch
+        def request(req, body = nil, &block)
+          # `request` calls itself once when the connection is not started.
+          unless started? && Thread.current[SpanCollector::THREAD_KEY] && !Errorgap::Delivery.sending?
+            return super
+          end
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          begin
+            super
+          ensure
+            elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000.0
+            Errorgap::Integrations::NetHTTP.record(req, address, elapsed_ms)
+          end
+        end
+      end
+
+      def self.record(request, host, elapsed_ms)
+        file, line, = SpanCollector.app_call_site
+        SpanCollector.store << Span.new(
+          kind: "http",
+          fn_name: "#{request.method} #{host}",
+          file: file, line: line,
+          duration_ms: elapsed_ms.round(3)
+        )
+      rescue StandardError
+        nil
+      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/integrations/sidekiq.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Errorgap
+  module Integrations
+    # Sidekiq server middleware: every job runs as a `job` transaction and an
+    # error it raises is reported with the job's class, queue, id and
+    # arguments, then re-raised so Sidekiq's retries work as before.
+    #
+    # Installed automatically when Sidekiq is loaded before errorgap is
+    # configured; otherwise:
+    #
+    #   Sidekiq.configure_server do |config|
+    #     config.server_middleware { |chain| chain.add Errorgap::Integrations::Sidekiq }
+    #   end
+    class Sidekiq
+      class << self
+        def install
+          return false unless defined?(::Sidekiq) && ::Sidekiq.respond_to?(:configure_server)
+          return true if @installed
+
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware { |chain| chain.add Errorgap::Integrations::Sidekiq }
+          end
+          @installed = true
+        end
+      end
+
+      def call(_worker, job, queue, &block)
+        # An ActiveJob run by Sidekiq is covered by the ActiveJob integration,
+        # which knows the real job class and its arguments.
+        return yield if job["wrapped"] && Errorgap::Integrations::ActiveJob.installed?
+
+        job_class = (job["wrapped"] || job["class"]).to_s
+        Errorgap.track_job(job_class, queue: queue.to_s) do
+          run(job, job_class, queue, &block)
+        end
+      ensure
+        Errorgap.clear_user
+      end
+
+      private
+
+      def run(job, job_class, queue)
+        yield
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        Errorgap.notify_once(
+          exception,
+          context: { component: "sidekiq", action: job_class },
+          environment: { queue: queue.to_s, job_id: job["jid"], retry_count: job["retry_count"] }.compact,
+          params: { "arguments" => job["args"] }
+        )
+        raise
+      end
+    end
+  end
+end

data/lib/errorgap/log_delivery.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
 require "time"
 
 module Errorgap
@@ -24,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))
@@ -39,27 +37,13 @@ module Errorgap
       if sync || !@configuration.async
         deliver(payload)
       else
-        Errorgap.register_thread(Thread.new { deliver(payload) })
+        Errorgap.delivery.enqueue("logs", payload)
         nil
       end
     end
 
     def deliver(payload)
-      uri = URI.join(
-        @configuration.endpoint.end_with?("/") ? @configuration.endpoint : "#{@configuration.endpoint}/",
-        "api/projects/#{@configuration.project_slug}/logs"
-      )
-      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] log delivery error: #{exception.class}: #{exception.message}")
+      Errorgap.delivery.post("logs", payload)
     end
 
     def self.normalize_level(level)
@@ -71,11 +55,5 @@ module Errorgap
     def self.rank(level)
       LEVELS.index(level) || LEVELS.index("info")
     end
-
-    private
-
-    def present?(value)
-      !value.nil? && !value.to_s.empty?
-    end
   end
 end

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
@@ -23,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,
@@ -33,11 +32,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 +48,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 +60,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,21 @@ 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
+        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/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