logister-ruby 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6f55dcaf8248136d818bf775ec1735e6b5340a83b4226eec28540679c3c2725
-  data.tar.gz: 773b83846639292bbdb935a333f3384f6d3b737c1d3933044a7d6a8c59884d84
+  metadata.gz: 0ffb0ff308c1a54f984e8c68088561c76a044e90766bee92a4ef23a51e0c5a78
+  data.tar.gz: fd0a658239131bec7061a722ed45044c0a2c7aba2125242b766837d0fd8d5dc8
 SHA512:
-  metadata.gz: e16455627f58c8793b8c317bde748e5a5288de2ca596bcfb641affc327737bc8de21e0b16ce36d749e53f29d95b773587808989acd792432a2125d7ed0ae8f02
-  data.tar.gz: 649f1cb0ff5aa498d03cc359d49dd9c77a64e07867f3ca92904a2552bb494d279addeba1cafd0048c68876f6f39e46cf77dfc7fecc7567d5a6c14c6d1ef8232b
+  metadata.gz: c89ea19d2cd68d4e7de0d85ff4b8c727fa0378d9a9e3b86e9a631fbb3e1a0df05d8cf7c9620636c9d7581011e53800cd57c9dffd7dabb9f83e52494c04d32c49
+  data.tar.gz: 42e48cd2049ab3adf2c496209dd71734891db9134f621920c988c138fb31bd3af99d1a72f39cc2b85f624f8f61ae586b873a036302fe0d29ca767d725cac4e9c

data/README.md

@@ -23,6 +23,21 @@ Logister.configure do |config|
   config.environment = Rails.env
   config.service = Rails.application.class.module_parent_name.underscore
   config.release = ENV["RELEASE_SHA"]
+
+  # Optional richer context hooks
+  config.anonymize_ip = false
+  config.max_breadcrumbs = 40
+  config.max_dependencies = 20
+  config.capture_sql_breadcrumbs = true
+  config.sql_breadcrumb_min_duration_ms = 25.0
+
+  config.feature_flags_resolver = lambda do |request:, user:, **|
+    { new_checkout: user&.respond_to?(:beta?) && user.beta? }
+  end
+
+  config.dependency_resolver = lambda do |**|
+    [] # or return [{ name:, host:, method:, status:, durationMs:, kind: }]
+  end
 end
 ```
 
@@ -55,6 +70,7 @@ end
 ## Rails auto-reporting
 
 If Rails is present, the gem installs middleware that reports unhandled exceptions automatically.
+It also attaches richer context (trace IDs, route/response/performance info, breadcrumbs, dependency calls, and user metadata when available).
 
 ## Database load metrics (ActiveRecord)
 
@@ -70,6 +86,37 @@ end
 
 This emits metric events with `message: "db.query"` and context fields such as `duration_ms`, `name`, `sql`, and `binds_count`.
 
+## Breadcrumbs and dependencies
+
+You can add manual breadcrumbs and dependency calls that will be attached to captured errors:
+
+```ruby
+Logister.add_breadcrumb(
+  category: "checkout",
+  message: "Starting payment authorization",
+  data: { order_id: 123 }
+)
+
+Logister.add_dependency(
+  name: "stripe.charge",
+  host: "api.stripe.com",
+  method: "POST",
+  status: 200,
+  duration_ms: 184.7,
+  kind: "http"
+)
+```
+
+The gem also captures request and SQL breadcrumbs automatically in Rails.
+
+## ActiveJob error context
+
+Failed ActiveJob executions are auto-reported with `job` context:
+- job class/id/queue/retries/schedule
+- filtered job arguments (using `filter_parameters`)
+- runtime/deployment metadata
+- breadcrumbs/dependency calls collected during the job
+
 ## Manual reporting
 
 ```ruby

data/lib/logister/active_job_reporter.rb

@@ -0,0 +1,83 @@
+require_relative "context_helpers"
+require_relative "context_store"
+
+module Logister
+  module ActiveJobReporter
+    def self.install!
+      return unless defined?(ActiveJob::Base)
+      return if ActiveJob::Base < Logister::ActiveJobReporter::Instrumentation
+
+      ActiveJob::Base.include(Logister::ActiveJobReporter::Instrumentation)
+    end
+
+    module Instrumentation
+      extend ActiveSupport::Concern
+
+      included do
+        around_perform do |job, block|
+          Logister::ContextStore.reset_request_scope!
+          Logister.add_breadcrumb(
+            category: "job",
+            message: "Starting #{job.class.name}",
+            data: { queue: job.queue_name, jobId: job.job_id }
+          )
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            block.call
+          rescue StandardError => error
+            Logister.report_error(
+              error,
+              context: Logister::ActiveJobReporter.build_job_error_context(job, started_at: started_at)
+            )
+            raise
+          ensure
+            Logister::ContextStore.reset_request_scope!
+          end
+        end
+      end
+    end
+
+    module_function
+
+    def build_job_error_context(job, started_at:)
+      Logister::ContextHelpers.compact_deep(
+        {
+          job: {
+            jobClass: job.class.name.to_s,
+            jobId: job.job_id.to_s.presence,
+            providerJobId: job.provider_job_id.to_s.presence,
+            queue: job.queue_name.to_s.presence,
+            priority: job.priority,
+            executions: job.executions,
+            exceptionExecutions: serialize_exception_executions(job),
+            locale: job.locale.to_s.presence,
+            timezone: (job.respond_to?(:timezone) ? job.timezone.to_s.presence : nil),
+            enqueuedAt: (job.respond_to?(:enqueued_at) ? time_to_iso8601(job.enqueued_at) : nil),
+            scheduledAt: time_to_iso8601(job.scheduled_at),
+            arguments: Logister::ContextHelpers.filtered_job_arguments(job)
+          }.compact,
+          breadcrumbs: Logister::ContextStore.breadcrumbs.presence,
+          dependencyCalls: Logister::ContextStore.dependencies.presence,
+          runtime: Logister::ContextHelpers.runtime_context[:runtime],
+          deployment: Logister::ContextHelpers.deployment_context[:deployment]
+        }
+      )
+    end
+
+    def serialize_exception_executions(job)
+      raw = job.respond_to?(:exception_executions) ? job.exception_executions : nil
+      return nil if raw.nil?
+
+      raw.is_a?(Hash) ? raw.transform_keys(&:to_s) : raw
+    end
+
+    def time_to_iso8601(value)
+      return nil unless value.respond_to?(:iso8601)
+
+      value.iso8601
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/logister/configuration.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'logger'
 
 module Logister
@@ -7,7 +5,10 @@ module Logister
     attr_accessor :api_key, :endpoint, :environment, :service, :release, :enabled, :timeout_seconds, :logger,
                   :ignore_exceptions, :ignore_environments, :ignore_paths, :before_notify,
                   :async, :queue_size, :max_retries, :retry_base_interval,
-                  :capture_db_metrics, :db_metric_min_duration_ms, :db_metric_sample_rate
+                  :capture_db_metrics, :db_metric_min_duration_ms, :db_metric_sample_rate,
+                  :feature_flags_resolver, :dependency_resolver, :anonymize_ip,
+                  :max_breadcrumbs, :max_dependencies,
+                  :capture_sql_breadcrumbs, :sql_breadcrumb_min_duration_ms
 
     def initialize
       @api_key = ENV['LOGISTER_API_KEY']
@@ -33,6 +34,14 @@ module Logister
       @capture_db_metrics = false
       @db_metric_min_duration_ms = 0.0
       @db_metric_sample_rate = 1.0
+
+      @feature_flags_resolver = nil
+      @dependency_resolver = nil
+      @anonymize_ip = false
+      @max_breadcrumbs = 40
+      @max_dependencies = 20
+      @capture_sql_breadcrumbs = true
+      @sql_breadcrumb_min_duration_ms = 25.0
     end
   end
 end

data/lib/logister/context_helpers.rb

@@ -0,0 +1,262 @@
+require "digest"
+require "socket"
+require "ipaddr"
+
+module Logister
+  module ContextHelpers
+    FILTERED_VALUE = "[FILTERED]".freeze
+
+    module_function
+
+    def runtime_context
+      {
+        runtime: {
+          rubyVersion: RUBY_VERSION,
+          railsVersion: defined?(Rails) ? Rails.version : nil,
+          rackVersion: defined?(Rack) ? Rack.release : nil,
+          platform: RUBY_PLATFORM
+        }.compact
+      }
+    end
+
+    def deployment_context
+      config = Logister.configuration if Logister.respond_to?(:configuration)
+      environment = config&.respond_to?(:environment) ? config.environment.to_s.presence : nil
+      service = config&.respond_to?(:service) ? config.service.to_s.presence : nil
+      release = config&.respond_to?(:release) ? config.release.to_s.presence : nil
+
+      {
+        deployment: {
+          environment: environment || ENV["RAILS_ENV"].to_s.presence || ENV["RACK_ENV"].to_s.presence || "development",
+          service: service || ENV["LOGISTER_SERVICE"].to_s.presence || "ruby-app",
+          release: release || ENV["LOGISTER_RELEASE"].to_s.presence,
+          region: ENV["FLY_REGION"].to_s.presence || ENV["RAILS_REGION"].to_s.presence || ENV["AWS_REGION"].to_s.presence,
+          hostname: Socket.gethostname.to_s.presence,
+          processPid: Process.pid
+        }.compact
+      }
+    end
+
+    def trace_context(headers:, env:)
+      traceparent = header_value(headers, "Traceparent")
+      b3_trace_id = header_value(headers, "X-B3-Traceid")
+      b3_span_id = header_value(headers, "X-B3-Spanid")
+      datadog_trace_id = header_value(headers, "X-Datadog-Trace-Id")
+      datadog_parent_id = header_value(headers, "X-Datadog-Parent-Id")
+      amzn_trace_id = header_value(headers, "X-Amzn-Trace-Id")
+
+      parsed_trace_id, parsed_span_id, parsed_sampled = parse_traceparent(traceparent)
+
+      {
+        trace: {
+          traceId: parsed_trace_id || b3_trace_id || datadog_trace_id,
+          spanId: parsed_span_id || b3_span_id || datadog_parent_id,
+          sampled: parsed_sampled,
+          traceparent: traceparent,
+          requestId: env["action_dispatch.request_id"].to_s.presence,
+          amznTraceId: amzn_trace_id
+        }.compact
+      }
+    end
+
+    def resolve_feature_flags(request:, env:, user:)
+      resolver = configuration_value(:feature_flags_resolver)
+      return {} unless resolver.respond_to?(:call)
+
+      raw = call_resolver(resolver, request: request, env: env, user: user)
+      flags = normalize_flags_hash(raw)
+      return {} if flags.empty?
+
+      { featureFlags: flags }
+    rescue StandardError
+      {}
+    end
+
+    def resolve_dependency_context(request:, env:)
+      resolver = configuration_value(:dependency_resolver)
+      return {} unless resolver.respond_to?(:call)
+
+      raw = call_resolver(resolver, request: request, env: env)
+      list = normalize_dependency_list(raw)
+      return {} if list.empty?
+
+      { dependencyCalls: list }
+    rescue StandardError
+      {}
+    end
+
+    def anonymize_ip(ip)
+      return nil if ip.to_s.strip.empty?
+      return ip.to_s unless configuration_value(:anonymize_ip, false)
+
+      parsed = IPAddr.new(ip.to_s)
+      if parsed.ipv4?
+        segments = ip.to_s.split(".")
+        return ip.to_s if segments.size != 4
+
+        "#{segments[0]}.#{segments[1]}.#{segments[2]}.0"
+      else
+        "#{parsed.mask(64).to_s}/64"
+      end
+    rescue StandardError
+      ip.to_s
+    end
+
+    def user_context_for(user)
+      return {} unless user
+
+      {
+        user: {
+          id: safe_call(user, :id).to_s.presence,
+          class: user.class.name.to_s.presence,
+          email_hash: hashed_email(user),
+          role: safe_call(user, :role).to_s.presence,
+          account_id: safe_call(user, :account_id).to_s.presence || safe_call(user, :tenant_id).to_s.presence
+        }.compact
+      }
+    end
+
+    def filtered_job_arguments(job)
+      arguments = Array(job.arguments)
+      return arguments if arguments.empty?
+
+      filter = ActiveSupport::ParameterFilter.new(
+        Array(Rails.application.config.filter_parameters)
+      )
+      arguments.map { |argument| filter_argument(argument, filter) }
+    rescue StandardError
+      arguments
+    end
+
+    def safe_call(object, method_name)
+      return nil unless object.respond_to?(method_name)
+
+      object.public_send(method_name)
+    rescue StandardError
+      nil
+    end
+
+    def hash_value(value)
+      return nil if value.to_s.strip.empty?
+
+      Digest::SHA256.hexdigest(value.to_s.strip.downcase)
+    end
+
+    def compact_deep(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, nested), acc|
+          compacted = compact_deep(nested)
+          next if blank_value?(compacted)
+
+          acc[key] = compacted
+        end
+      when Array
+        value.map { |item| compact_deep(item) }.reject { |item| blank_value?(item) }
+      else
+        value
+      end
+    end
+
+    def blank_value?(value)
+      value.nil? || (value.respond_to?(:empty?) && value.empty?)
+    end
+
+    def hashed_email(user)
+      email = safe_call(user, :email)
+      hash_value(email)
+    end
+    private_class_method :hashed_email
+
+    def filter_argument(argument, filter)
+      case argument
+      when Hash
+        filter.filter(argument)
+      when Array
+        argument.map { |nested| filter_argument(nested, filter) }
+      else
+        argument
+      end
+    end
+    private_class_method :filter_argument
+
+    def header_value(headers, key)
+      return nil unless headers.is_a?(Hash)
+
+      headers[key].presence || headers[key.downcase].presence || headers[key.upcase].presence
+    end
+    private_class_method :header_value
+
+    def parse_traceparent(traceparent)
+      return [ nil, nil, nil ] if traceparent.to_s.empty?
+
+      parts = traceparent.to_s.split("-")
+      return [ nil, nil, nil ] unless parts.size == 4
+
+      trace_id = parts[1].to_s
+      span_id = parts[2].to_s
+      flags = parts[3].to_s
+      sampled = flags.end_with?("01")
+
+      [ trace_id.presence, span_id.presence, sampled ]
+    rescue StandardError
+      [ nil, nil, nil ]
+    end
+    private_class_method :parse_traceparent
+
+    def normalize_flags_hash(raw)
+      case raw
+      when Hash
+        raw.each_with_object({}) do |(key, value), acc|
+          acc[key.to_s] = value
+        end
+      else
+        {}
+      end
+    end
+    private_class_method :normalize_flags_hash
+
+    def normalize_dependency_list(raw)
+      list = case raw
+      when Array then raw
+      when Hash then [ raw ]
+      else []
+      end
+
+      list.map do |item|
+        next unless item.is_a?(Hash)
+
+        {
+          name: item[:name] || item["name"],
+          host: item[:host] || item["host"],
+          method: item[:method] || item["method"],
+          status: item[:status] || item["status"],
+          durationMs: item[:durationMs] || item["durationMs"] || item[:duration_ms] || item["duration_ms"],
+          kind: item[:kind] || item["kind"],
+          error: item[:error] || item["error"]
+        }.compact
+      end.compact
+    end
+    private_class_method :normalize_dependency_list
+
+    def configuration_value(key, fallback = nil)
+      return fallback unless Logister.respond_to?(:configuration)
+
+      Logister.configuration.public_send(key)
+    rescue StandardError
+      fallback
+    end
+    private_class_method :configuration_value
+
+    def call_resolver(resolver, **kwargs)
+      if resolver.arity == 1
+        resolver.call(kwargs)
+      else
+        resolver.call(**kwargs)
+      end
+    rescue ArgumentError
+      resolver.call(kwargs[:request], kwargs[:env], kwargs[:user])
+    end
+    private_class_method :call_resolver
+  end
+end

data/lib/logister/context_store.rb

@@ -0,0 +1,134 @@
+module Logister
+  module ContextStore
+    REQUEST_SCOPE_KEY = :__logister_request_scope
+    MAX_REQUEST_SUMMARIES = 200
+
+    module_function
+
+    def reset_request_scope!
+      Thread.current[REQUEST_SCOPE_KEY] = {
+        breadcrumbs: [],
+        dependencies: []
+      }
+    end
+
+    def add_breadcrumb(category:, message:, data: {}, level: "info", timestamp: Time.now.utc.iso8601)
+      scope = request_scope
+      breadcrumbs = scope[:breadcrumbs]
+      breadcrumbs << {
+        category: category.to_s,
+        message: message.to_s,
+        level: level.to_s,
+        timestamp: timestamp,
+        data: sanitize_hash(data)
+      }.compact
+      trim_collection!(breadcrumbs, max_breadcrumbs)
+    end
+
+    def breadcrumbs
+      request_scope[:breadcrumbs].dup
+    end
+
+    def add_dependency(name:, host: nil, method: nil, status: nil, duration_ms: nil, kind: nil, data: {})
+      scope = request_scope
+      deps = scope[:dependencies]
+      deps << sanitize_hash(
+        {
+          name: name.to_s.presence,
+          host: host.to_s.presence,
+          method: method.to_s.presence,
+          status: status,
+          durationMs: duration_ms && duration_ms.to_f.round(2),
+          kind: kind.to_s.presence,
+          data: sanitize_hash(data)
+        }.compact
+      )
+      trim_collection!(deps, max_dependencies)
+    end
+
+    def dependencies
+      request_scope[:dependencies].dup
+    end
+
+    def store_request_summary(request_id, summary)
+      return if request_id.to_s.empty?
+
+      cache = request_summaries
+      cache[request_id.to_s] = sanitize_hash(summary)
+      trim_hash!(cache, MAX_REQUEST_SUMMARIES)
+    end
+
+    def request_summary(request_id)
+      return nil if request_id.to_s.empty?
+
+      request_summaries[request_id.to_s]
+    end
+
+    def clear_request_summary(request_id)
+      request_summaries.delete(request_id.to_s)
+    end
+
+    def add_manual_dependency(**kwargs)
+      add_dependency(**kwargs)
+    end
+
+    def add_manual_breadcrumb(**kwargs)
+      add_breadcrumb(**kwargs)
+    end
+
+    def request_scope
+      Thread.current[REQUEST_SCOPE_KEY] ||= {
+        breadcrumbs: [],
+        dependencies: []
+      }
+    end
+    private_class_method :request_scope
+
+    def request_summaries
+      Thread.current[:__logister_request_summaries] ||= {}
+    end
+    private_class_method :request_summaries
+
+    def sanitize_hash(value)
+      return {} unless value.is_a?(Hash)
+
+      value.each_with_object({}) do |(key, nested), acc|
+        acc[key] = nested
+      end
+    end
+    private_class_method :sanitize_hash
+
+    def max_breadcrumbs
+      config_value(:max_breadcrumbs, 40).to_i.clamp(1, 500)
+    end
+    private_class_method :max_breadcrumbs
+
+    def max_dependencies
+      config_value(:max_dependencies, 20).to_i.clamp(1, 500)
+    end
+    private_class_method :max_dependencies
+
+    def trim_collection!(array, max_size)
+      overflow = array.size - max_size
+      array.shift(overflow) if overflow.positive?
+    end
+    private_class_method :trim_collection!
+
+    def trim_hash!(hash, max_size)
+      overflow = hash.size - max_size
+      return unless overflow.positive?
+
+      hash.keys.first(overflow).each { |key| hash.delete(key) }
+    end
+    private_class_method :trim_hash!
+
+    def config_value(key, fallback)
+      return fallback unless Logister.respond_to?(:configuration)
+
+      Logister.configuration.public_send(key)
+    rescue StandardError
+      fallback
+    end
+    private_class_method :config_value
+  end
+end

data/lib/logister/middleware.rb

@@ -1,83 +1,202 @@
-# frozen_string_literal: true
-
-require 'socket'
+require_relative "context_helpers"
+require_relative "context_store"
 
 module Logister
   class Middleware
-    # Sensitive param key fragments matched case-insensitively.
-    SENSITIVE_PARAM_RE = /password|token|secret|api_key|credit_card|cvv|ssn/i.freeze
-    FILTERED           = '[FILTERED]'
+    FILTERED_HEADER_PLACEHOLDER = "[FILTERED]".freeze
+    SENSITIVE_HEADERS = %w[authorization cookie set-cookie x-api-key x-csrf-token].freeze
 
     def initialize(app)
       @app = app
-
-      # Cache values that are constant for the lifetime of this process so
-      # they are not recomputed on every error.
-      @hostname    = resolve_hostname.freeze
-      @app_context = build_app_context.freeze
     end
 
     def call(env)
+      Logister::ContextStore.reset_request_scope!
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @app.call(env)
     rescue StandardError => e
+      request = ActionDispatch::Request.new(env)
+      request_context = build_request_context(request, env, error: e, started_at: started_at)
+
       Logister.report_error(
         e,
-        context: {
-          request: build_request_context(env),
-          app:     @app_context
-        }
+        context: request_context
       )
       raise
+    ensure
+      request_id = env["action_dispatch.request_id"]
+      Logister::ContextStore.clear_request_summary(request_id)
+      Logister::ContextStore.reset_request_scope!
     end
 
     private
 
-    def build_request_context(env)
-      ctx = {
-        id:         env['action_dispatch.request_id'],
-        path:       env['PATH_INFO'],
-        method:     env['REQUEST_METHOD'],
-        ip:         remote_ip(env),
-        user_agent: env['HTTP_USER_AGENT']
-      }
-
-      # Params — available if ActionDispatch has already parsed them.
-      if (params = env['action_dispatch.request.parameters'])
-        ctx[:params] = filter_params(params)
+    def build_request_context(request, env, error:, started_at:)
+      request_id = env["action_dispatch.request_id"].to_s.presence
+      path = request.path.to_s
+      method = request.request_method.to_s
+      params = request.filtered_parameters.to_h
+      headers = extract_headers(env)
+      referer = request.referer.to_s.presence || headers["Referer"]
+      http_version = env["HTTP_VERSION"].to_s.presence || env["SERVER_PROTOCOL"].to_s.presence
+      rails_action = rails_action_name(params)
+      response_status = response_status_for(error)
+      duration_ms = elapsed_duration_ms(started_at)
+      current_user = current_user(env)
+      user_context = Logister::ContextHelpers.user_context_for(current_user)
+      request_summary = Logister::ContextStore.request_summary(request_id) || {}
+      dependencies = collected_dependencies(request: request, env: env)
+      breadcrumbs = Logister::ContextStore.breadcrumbs
+      feature_flags = Logister::ContextHelpers.resolve_feature_flags(request: request, env: env, user: current_user)
+      trace_context = Logister::ContextHelpers.trace_context(headers: headers, env: env)
+      client_ip = Logister::ContextHelpers.anonymize_ip(request.ip.to_s.presence)
+
+      base_context = {
+        request_id: request_id,
+        path: path,
+        method: method,
+        clientIp: client_ip,
+        headers: headers,
+        httpMethod: method,
+        httpVersion: http_version,
+        params: params,
+        railsAction: rails_action,
+        referer: referer,
+        requestId: request_id,
+        url: request.original_url.to_s.presence,
+        response: {
+          status: request_summary[:status] || response_status,
+          contentType: request.content_type.to_s.presence,
+          format: request_summary[:format] || request.format&.to_s.presence,
+          durationMs: duration_ms
+        }.compact,
+        route: {
+          name: env["action_dispatch.route_name"].to_s.presence,
+          pathTemplate: route_path_template(env),
+          controller: request_summary[:controller] || route_value(params, "controller"),
+          action: request_summary[:action] || route_value(params, "action")
+        }.compact,
+        performance: {
+          dbRuntimeMs: request_summary[:dbRuntimeMs],
+          viewRuntimeMs: request_summary[:viewRuntimeMs],
+          allocations: request_summary[:allocations]
+        }.compact,
+        dependencyCalls: dependencies.presence,
+        breadcrumbs: breadcrumbs.presence,
+        request: {
+          clientIp: client_ip,
+          headers: headers,
+          httpMethod: method,
+          httpVersion: http_version,
+          params: params,
+          railsAction: rails_action,
+          referer: referer,
+          requestId: request_id,
+          url: request.original_url.to_s.presence
+        }.compact
+      }.compact
+
+      Logister::ContextHelpers.compact_deep(
+        base_context
+          .merge(trace_context)
+          .merge(feature_flags)
+          .merge(user_context)
+          .merge(Logister::ContextHelpers.runtime_context)
+          .merge(Logister::ContextHelpers.deployment_context)
+      )
+    end
+
+    def rails_action_name(params)
+      return nil unless params.is_a?(Hash)
+
+      controller_name = params["controller"].to_s.presence || params[:controller].to_s.presence
+      action_name = params["action"].to_s.presence || params[:action].to_s.presence
+      return nil if controller_name.blank? || action_name.blank?
+
+      "#{controller_name}##{action_name}"
+    end
+
+    def extract_headers(env)
+      headers = {}
+
+      env.each do |key, value|
+        next unless value.is_a?(String)
+
+        header_name = rack_env_to_header_name(key)
+        next unless header_name
+
+        headers[header_name] = filter_header_value(header_name, value)
       end
 
-      ctx.compact
+      headers.sort.to_h
     end
 
-    def build_app_context
-      ctx = { ruby: RUBY_VERSION, hostname: @hostname }
-      ctx[:rails] = Rails::VERSION::STRING if defined?(Rails::VERSION)
-      ctx
+    def rack_env_to_header_name(key)
+      if key.start_with?("HTTP_")
+        key.delete_prefix("HTTP_").split("_").map(&:capitalize).join("-")
+      elsif key == "CONTENT_TYPE"
+        "Content-Type"
+      elsif key == "CONTENT_LENGTH"
+        "Content-Length"
+      else
+        nil
+      end
     end
 
-    # Respect X-Forwarded-For set by proxies; fall back to REMOTE_ADDR.
-    def remote_ip(env)
-      forwarded = env['HTTP_X_FORWARDED_FOR']
-      return env['REMOTE_ADDR'] if forwarded.nil? || forwarded.empty?
+    def filter_header_value(name, value)
+      return FILTERED_HEADER_PLACEHOLDER if SENSITIVE_HEADERS.include?(name.to_s.downcase)
 
-      first = forwarded.split(',').first
-      first ? first.strip : env['REMOTE_ADDR']
+      value
     end
 
-    # Filter out sensitive parameter values using a single Regexp so we avoid
-    # allocating a downcased String for every param key on every error.
-    def filter_params(params)
-      params.each_with_object({}) do |(k, v), h|
-        h[k] = k.to_s.match?(SENSITIVE_PARAM_RE) ? FILTERED : v
+    def current_user(env)
+      controller = env["action_controller.instance"]
+      return nil unless controller
+
+      if controller.respond_to?(:current_user)
+        controller.public_send(:current_user)
+      elsif controller.respond_to?(:current_user, true)
+        controller.send(:current_user)
       end
     rescue StandardError
-      {}
+      nil
+    end
+
+    def collected_dependencies(request:, env:)
+      custom = Logister::ContextHelpers.resolve_dependency_context(request: request, env: env).fetch(:dependencyCalls, [])
+      manual = Logister::ContextStore.dependencies
+      Array(manual) + Array(custom)
+    end
+
+    def response_status_for(error)
+      return 500 unless defined?(ActionDispatch::ExceptionWrapper)
+
+      ActionDispatch::ExceptionWrapper.status_code_for_exception(error.class.name)
+    rescue StandardError
+      500
     end
 
-    def resolve_hostname
-      Socket.gethostname
+    def elapsed_duration_ms(started_at)
+      return nil unless started_at
+
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000.0).round(2)
     rescue StandardError
-      'unknown'
+      nil
+    end
+
+    def route_path_template(env)
+      pattern = env["action_dispatch.route_uri_pattern"]
+      return pattern.spec.to_s.presence if pattern.respond_to?(:spec)
+
+      pattern.to_s.presence
+    rescue StandardError
+      nil
+    end
+
+    def route_value(params, key)
+      return nil unless params.is_a?(Hash)
+
+      params[key].to_s.presence || params[key.to_sym].to_s.presence
     end
   end
 end

data/lib/logister/railtie.rb

@@ -1,6 +1,5 @@
-# frozen_string_literal: true
-
 require 'rails/railtie'
+require_relative 'active_job_reporter'
 
 module Logister
   class Railtie < Rails::Railtie
@@ -26,6 +25,13 @@ module Logister
         copy_setting(app, config, :capture_db_metrics)
         copy_setting(app, config, :db_metric_min_duration_ms)
         copy_setting(app, config, :db_metric_sample_rate)
+        copy_setting(app, config, :feature_flags_resolver)
+        copy_setting(app, config, :dependency_resolver)
+        copy_setting(app, config, :anonymize_ip)
+        copy_setting(app, config, :max_breadcrumbs)
+        copy_setting(app, config, :max_dependencies)
+        copy_setting(app, config, :capture_sql_breadcrumbs)
+        copy_setting(app, config, :sql_breadcrumb_min_duration_ms)
       end
     end
 
@@ -37,13 +43,23 @@ module Logister
       Logister::SqlSubscriber.install!
     end
 
+    initializer "logister.request_subscriber" do
+      Logister::RequestSubscriber.install!
+    end
+
+    initializer "logister.active_job_reporter" do
+      ActiveSupport.on_load(:active_job) do
+        Logister::ActiveJobReporter.install!
+      end
+    end
+
     private
 
     def copy_setting(app, config, key)
-      value = app.config.logister.public_send(key)
+      value = app.config.logister.send(key)
       return if value.nil?
 
-      config.public_send(:"#{key}=", value)
+      config.send("#{key}=", value)
     end
   end
 end

data/lib/logister/request_subscriber.rb

@@ -0,0 +1,104 @@
+require "logger"
+
+module Logister
+  class RequestSubscriber
+    IGNORED_SQL_NAMES = %w[SCHEMA TRANSACTION].freeze
+
+    class << self
+      def install!
+        return if @installed
+
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |_name, _started, _finished, _id, payload|
+          handle_process_action(payload)
+        end
+
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, started, finished, _id, payload|
+          handle_sql_breadcrumb(started, finished, payload)
+        end
+
+        @installed = true
+      end
+
+      private
+
+      def handle_process_action(payload)
+        return unless payload.is_a?(Hash)
+
+        request_id = payload[:request_id].to_s.presence
+        return unless request_id
+
+        Logister::ContextStore.store_request_summary(
+          request_id,
+          {
+            status: payload[:status],
+            format: payload[:format].to_s.presence,
+            method: payload[:method].to_s.presence,
+            path: payload[:path].to_s.presence,
+            controller: payload[:controller].to_s.presence,
+            action: payload[:action].to_s.presence,
+            dbRuntimeMs: numeric(payload[:db_runtime]),
+            viewRuntimeMs: numeric(payload[:view_runtime]),
+            allocations: payload[:allocations]
+          }.compact
+        )
+
+        Logister.add_breadcrumb(
+          category: "request",
+          message: "#{payload[:controller]}##{payload[:action]} completed",
+          data: {
+            status: payload[:status],
+            method: payload[:method],
+            path: payload[:path],
+            dbRuntimeMs: numeric(payload[:db_runtime]),
+            viewRuntimeMs: numeric(payload[:view_runtime])
+          }.compact
+        )
+      rescue StandardError => e
+        logger.warn("logister request subscriber (process_action) failed: #{e.class} #{e.message}")
+      end
+
+      def handle_sql_breadcrumb(started, finished, payload)
+        config = configuration
+        return unless config&.capture_sql_breadcrumbs
+        return unless payload.is_a?(Hash)
+        return if payload[:cached]
+        return if IGNORED_SQL_NAMES.include?(payload[:name].to_s)
+
+        duration_ms = ((finished - started) * 1000.0).round(2)
+        return if duration_ms < config.sql_breadcrumb_min_duration_ms.to_f
+
+        sql_name = payload[:name].to_s.presence || "SQL"
+        Logister.add_breadcrumb(
+          category: "db",
+          message: "#{sql_name} query",
+          data: {
+            durationMs: duration_ms,
+            sql: payload[:sql].to_s[0, 250]
+          }
+        )
+      rescue StandardError => e
+        logger.warn("logister request subscriber (sql breadcrumb) failed: #{e.class} #{e.message}")
+      end
+
+      def numeric(value)
+        return nil if value.nil?
+
+        value.to_f.round(2)
+      end
+
+      def configuration
+        return nil unless Logister.respond_to?(:configuration)
+
+        Logister.configuration
+      rescue StandardError
+        nil
+      end
+
+      def logger
+        configuration&.logger || Logger.new($stdout)
+      rescue StandardError
+        Logger.new($stdout)
+      end
+    end
+  end
+end

data/lib/logister/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Logister
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/lib/logister.rb

@@ -1,11 +1,12 @@
-# frozen_string_literal: true
-
 require_relative 'logister/version'
 require_relative 'logister/configuration'
 require_relative 'logister/client'
 require_relative 'logister/reporter'
+require_relative 'logister/context_helpers'
+require_relative 'logister/context_store'
 require_relative 'logister/middleware'
 require_relative 'logister/sql_subscriber'
+require_relative 'logister/request_subscriber'
 
 module Logister
   class << self
@@ -30,14 +31,6 @@ module Logister
       reporter.report_metric(**kwargs)
     end
 
-    def set_user(id: nil, email: nil, name: nil, **extra)
-      reporter.set_user(id: id, email: email, name: name, **extra)
-    end
-
-    def clear_user
-      reporter.clear_user
-    end
-
     def flush(timeout: 2)
       reporter.flush(timeout: timeout)
     end
@@ -45,6 +38,27 @@ module Logister
     def shutdown
       reporter.shutdown
     end
+
+    def add_breadcrumb(category:, message:, data: {}, level: "info")
+      ContextStore.add_manual_breadcrumb(
+        category: category,
+        message: message,
+        data: data,
+        level: level
+      )
+    end
+
+    def add_dependency(name:, host: nil, method: nil, status: nil, duration_ms: nil, kind: nil, data: {})
+      ContextStore.add_manual_dependency(
+        name: name,
+        host: host,
+        method: method,
+        status: status,
+        duration_ms: duration_ms,
+        kind: kind,
+        data: data
+      )
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logister-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Logister
@@ -50,11 +50,15 @@ files:
 - lib/generators/logister/templates/logister.rb
 - lib/logister-ruby.rb
 - lib/logister.rb
+- lib/logister/active_job_reporter.rb
 - lib/logister/client.rb
 - lib/logister/configuration.rb
+- lib/logister/context_helpers.rb
+- lib/logister/context_store.rb
 - lib/logister/middleware.rb
 - lib/logister/railtie.rb
 - lib/logister/reporter.rb
+- lib/logister/request_subscriber.rb
 - lib/logister/sql_subscriber.rb
 - lib/logister/version.rb
 - logister-ruby.gemspec