logister-ruby 0.2.0 → 0.2.2

data/lib/logister/middleware.rb

@@ -1,74 +1,202 @@
-require 'socket'
+require_relative "context_helpers"
+require_relative "context_store"
 
 module Logister
   class Middleware
+    FILTERED_HEADER_PLACEHOLDER = "[FILTERED]".freeze
+    SENSITIVE_HEADERS = %w[authorization cookie set-cookie x-api-key x-csrf-token].freeze
+
     def initialize(app)
       @app = app
     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:     build_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'].to_s.split(',').first&.strip
-      forwarded.nil? || forwarded.empty? ? env['REMOTE_ADDR'] : forwarded
+    def filter_header_value(name, value)
+      return FILTERED_HEADER_PLACEHOLDER if SENSITIVE_HEADERS.include?(name.to_s.downcase)
+
+      value
     end
 
-    # Remove sensitive parameter values the same way Rails does
-    SENSITIVE_PARAMS = %w[password password_confirmation token secret api_key
-                          credit_card cvv ssn].freeze
+    def current_user(env)
+      controller = env["action_controller.instance"]
+      return nil unless controller
 
-    def filter_params(params)
-      params.each_with_object({}) do |(k, v), h|
-        h[k] = SENSITIVE_PARAMS.any? { |s| k.to_s.downcase.include?(s) } ? '[FILTERED]' : v
+      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 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,4 +1,5 @@
 require 'rails/railtie'
+require_relative 'active_job_reporter'
 
 module Logister
   class Railtie < Rails::Railtie
@@ -24,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
 
@@ -35,6 +43,16 @@ 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)

data/lib/logister/reporter.rb

@@ -1,13 +1,40 @@
+# frozen_string_literal: true
+
 require 'digest'
 require 'time'
+require 'set'
 
 module Logister
   class Reporter
     def initialize(configuration)
       @configuration = configuration
-      @client = Client.new(configuration)
-
-      at_exit { shutdown }
+      @client        = Client.new(configuration)
+
+      # Pre-build values that are static for the lifetime of this reporter so
+      # they are not allocated on every report_error / report_metric call.
+      @static_context = {
+        environment: @configuration.environment,
+        service:     @configuration.service,
+        release:     @configuration.release
+      }.freeze
+
+      # Normalise ignore_environments once into a frozen Set of Strings so
+      # ignored_environment? never allocates a mapped Array.
+      @ignored_envs = Set.new(@configuration.ignore_environments.map(&:to_s)).freeze
+
+      # Cache the current-environment String to avoid repeated .to_s calls.
+      @current_env = @configuration.environment.to_s.freeze
+
+      # Compile the app-root stripping Regexp once; Dir.pwd is a syscall that
+      # always returns a new String — do it exactly once here.
+      app_root = Dir.pwd.to_s.freeze
+      @app_root_re = /\A#{Regexp.escape(app_root)}\//.freeze
+
+      # Register shutdown hook. Guard with a flag so multiple Reporter instances
+      # (created by repeated Logister.configure calls) each shut down cleanly
+      # without re-registering more handlers.
+      @shutdown_registered = false
+      register_shutdown_hook
     end
 
     def report_error(exception, context: {}, tags: {}, level: 'error', fingerprint: nil)
@@ -15,17 +42,18 @@ module Logister
       return false if ignored_path?(context)
 
       merged_context = context.dup
-      merged_context[:user] = current_user_context if current_user_context
+      user = current_user_context
+      merged_context[:user] = user if user
 
       payload = build_payload(
-        event_type: 'error',
-        level: level,
-        message: "#{exception.class}: #{exception.message}",
+        event_type:  'error',
+        level:       level,
+        message:     "#{exception.class}: #{exception.message}",
         fingerprint: fingerprint || default_fingerprint(exception),
-        context: merged_context.merge(
+        context:     merged_context.merge(
           exception: {
-            class: exception.class.to_s,
-            message: exception.message.to_s,
+            class:     exception.class.to_s,
+            message:   exception.message.to_s,
             backtrace: Array(exception.backtrace).first(50)
           },
           tags: tags
@@ -43,11 +71,11 @@ module Logister
       return false if ignored_path?(context)
 
       payload = build_payload(
-        event_type: 'metric',
-        level: level,
-        message: message,
-        fingerprint: fingerprint || Digest::SHA256.hexdigest(message.to_s)[0, 32],
-        context: context.merge(tags: tags)
+        event_type:  'metric',
+        level:       level,
+        message:     message,
+        fingerprint: fingerprint || metric_fingerprint(message),
+        context:     context.merge(tags: tags)
       )
 
       payload = apply_before_notify(payload)
@@ -80,22 +108,31 @@ module Logister
 
     private
 
+    def register_shutdown_hook
+      return if @shutdown_registered
+
+      @shutdown_registered = true
+      # Capture @client directly (not self) so the at_exit proc does not
+      # retain the entire Reporter in the finalizer chain.
+      client = @client
+      at_exit { client.shutdown }
+    end
+
     def current_user_context
       Thread.current[:logister_user]
     end
 
     def build_payload(event_type:, level:, message:, fingerprint:, context:)
       {
-        event_type: event_type,
-        level: level,
-        message: message,
+        event_type:  event_type,
+        level:       level,
+        message:     message,
         fingerprint: fingerprint,
         occurred_at: Time.now.utc.iso8601,
-        context: context.merge(
-          environment: @configuration.environment,
-          service: @configuration.service,
-          release: @configuration.release
-        )
+        # Merge static config context last so caller-supplied keys are not
+        # overwritten, then merge the static values. The static_context Hash
+        # is frozen and reused — only the new outer Hash is allocated.
+        context:     @static_context.merge(context)
       }
     end
 
@@ -125,31 +162,39 @@ module Logister
     end
 
     def ignored_environment?
-      env = @configuration.environment.to_s
-      @configuration.ignore_environments.map(&:to_s).include?(env)
+      @ignored_envs.include?(@current_env)
     end
 
     def ignored_path?(context)
       path = context[:path] || context['path']
       return false if path.to_s.empty?
 
+      path_s = path.to_s
       @configuration.ignore_paths.any? do |matcher|
-        matcher.is_a?(Regexp) ? matcher.match?(path.to_s) : path.to_s.include?(matcher.to_s)
+        matcher.is_a?(Regexp) ? matcher.match?(path_s) : path_s.include?(matcher.to_s)
       end
     end
 
+    # Cache metric fingerprints — metric messages are typically a small fixed
+    # set of constants (e.g. 'db.query') so the SHA256 is identical every call.
+    def metric_fingerprint(message)
+      @metric_fingerprint_cache ||= {}
+      key = message.to_s
+      @metric_fingerprint_cache[key] ||=
+        Digest::SHA256.hexdigest(key)[0, 32].freeze
+    end
+
     def default_fingerprint(exception)
       # Prefer class + first backtrace location so that errors with dynamic
       # values in their message (e.g. "Couldn't find User with 'id'=42") still
       # group together across different IDs / UUIDs.
       location = Array(exception.backtrace).first.to_s
-                                           .sub(/:in\s+.+$/, '')  # strip method name
-                                           .sub(/\A.*\/gems\//, 'gems/')  # normalise gem paths
-                                           .sub(/\A#{Regexp.escape(Dir.pwd.to_s)}\//, '')  # strip app root
+                                           .sub(/:in\s+.+$/, '')       # strip method name
+                                           .sub(/\A.*\/gems\//, 'gems/') # normalise gem paths
+                                           .sub(@app_root_re, '')       # strip app root (pre-compiled RE)
 
       if location.empty?
-        # No backtrace available — scrub common dynamic tokens from the message
-        # before hashing so that e.g. "id=42" and "id=99" hash the same way.
+        # No backtrace — scrub dynamic tokens from the message before hashing.
         scrubbed = scrub_dynamic_values(exception.message.to_s)
         Digest::SHA256.hexdigest("#{exception.class}|#{scrubbed}")[0, 32]
       else
@@ -157,18 +202,18 @@ module Logister
       end
     end
 
-    # Strip values that tend to vary per-occurrence but carry no grouping signal:
-    #   - numeric IDs:     id=42, 'id'=42, id: 42
+    # Strip values that vary per-occurrence but carry no grouping signal:
+    #   - numeric IDs:  id=42, 'id'=42, id: 42
     #   - UUIDs
     #   - hex digests (≥8 hex chars)
     #   - quoted string values in ActiveRecord-style messages
     def scrub_dynamic_values(message)
       message
-        .gsub(/\b(id['"]?\s*[=:]\s*)\d+/i,        '\1?')
-        .gsub(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i, '?')
-        .gsub(/\b[0-9a-f]{8,}\b/,                  '?')
-        .gsub(/'[^']{1,64}'/,                       '?')
-        .gsub(/\d+/,                                '?')
+        .gsub(/\b(id['"]?\s*[=:]\s*)\d+/i,                                         '\1?')
+        .gsub(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i,   '?')
+        .gsub(/\b[0-9a-f]{8,}\b/,                                                   '?')
+        .gsub(/'[^']{1,64}'/,                                                        '?')
+        .gsub(/\d+/,                                                                 '?')
     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/sql_subscriber.rb

@@ -1,13 +1,26 @@
+# frozen_string_literal: true
+
 module Logister
   class SqlSubscriber
     IGNORED_SQL_NAMES = %w[SCHEMA TRANSACTION].freeze
 
+    # Frozen constants for values emitted on every captured query.
+    MESSAGE       = 'db.query'
+    LEVEL_WARN    = 'warn'
+    LEVEL_INFO    = 'info'
+    TAGS          = { category: 'database' }.freeze
+
+    # Pre-compute the fingerprint for the fixed message string so we pay the
+    # SHA256 cost exactly once instead of on every captured SQL query.
+    require 'digest'
+    SQL_FINGERPRINT = Digest::SHA256.hexdigest(MESSAGE)[0, 32].freeze
+
     class << self
       def install!
         return if @installed
 
-        ActiveSupport::Notifications.subscribe('sql.active_record') do |name, started, finished, _id, payload|
-          handle_sql_event(name, started, finished, payload)
+        ActiveSupport::Notifications.subscribe('sql.active_record') do |_name, started, finished, _id, payload|
+          handle_sql_event(started, finished, payload)
         end
 
         @installed = true
@@ -15,31 +28,34 @@ module Logister
 
       private
 
-      def handle_sql_event(_name, started, finished, payload)
+      def handle_sql_event(started, finished, payload)
         config = Logister.configuration
+
+        # Short-circuit as cheaply as possible when metrics are disabled so
+        # that *every* SQL query in the app pays minimal overhead.
         return unless config.capture_db_metrics
         return if payload[:cached]
-        return if IGNORED_SQL_NAMES.include?(payload[:name].to_s)
+
+        # Evaluate name once — it's used in two places below.
+        sql_name = payload[:name].to_s
+        return if IGNORED_SQL_NAMES.include?(sql_name)
 
         duration_ms = (finished - started) * 1000.0
         return if duration_ms < config.db_metric_min_duration_ms.to_f
         return if sampled_out?(config.db_metric_sample_rate)
 
-        level = duration_ms >= 500 ? 'warn' : 'info'
-
         Logister.report_metric(
-          message: 'db.query',
-          level: level,
+          message:     MESSAGE,
+          level:       duration_ms >= 500 ? LEVEL_WARN : LEVEL_INFO,
+          fingerprint: SQL_FINGERPRINT,
           context: {
             duration_ms: duration_ms.round(2),
-            name: payload[:name].to_s,
-            sql: payload[:sql].to_s,
-            cached: false,
-            binds_count: Array(payload[:binds]).size
+            name:        sql_name,
+            sql:         payload[:sql].to_s,
+            cached:      false,
+            binds_count: (payload[:binds] || []).size
           },
-          tags: {
-            category: 'database'
-          }
+          tags: TAGS
         )
       rescue StandardError => e
         config.logger.warn("logister sql subscriber failed: #{e.class} #{e.message}")

data/lib/logister/version.rb

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