logister-ruby 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3ffbd6d90538c5e0cf39deab256aaf1b0c5c15f5899051e67cfedc6657ac4b5
-  data.tar.gz: af860be23dab9bd73c8d394e9b1b91b6076f62a6a5f67272991afafba75d83a6
+  metadata.gz: d6f55dcaf8248136d818bf775ec1735e6b5340a83b4226eec28540679c3c2725
+  data.tar.gz: 773b83846639292bbdb935a333f3384f6d3b737c1d3933044a7d6a8c59884d84
 SHA512:
-  metadata.gz: 59875a74fdee52e22b697b80e4840ba070db495eb905b47d6522576f2e745d4f64081bf0fbf5f8e7cfc48917466c1a8724a389fe36f728b29080ff71dcb79165
-  data.tar.gz: fb8e6d1898621e57f2fdb9c66a3e08b655151f3f06ed830e5e2a8c96313c4b1e181c1281846a2a62ada0d7332d8a9631630bb5b9abe9bf7a4fc4f14e04a781a3
+  metadata.gz: e16455627f58c8793b8c317bde748e5a5288de2ca596bcfb641affc327737bc8de21e0b16ce36d749e53f29d95b773587808989acd792432a2125d7ed0ae8f02
+  data.tar.gz: 649f1cb0ff5aa498d03cc359d49dd9c77a64e07867f3ca92904a2552bb494d279addeba1cafd0048c68876f6f39e46cf77dfc7fecc7567d5a6c14c6d1ef8232b

data/lib/logister/client.rb

@@ -1,15 +1,25 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'net/http'
 require 'uri'
 
 module Logister
   class Client
+    CONTENT_TYPE = 'application/json'
+
     def initialize(configuration)
       @configuration = configuration
-      @worker_mutex = Mutex.new
-      @queue = SizedQueue.new(@configuration.queue_size)
-      @worker = nil
-      @running = false
+      @worker_mutex  = Mutex.new
+      @queue         = SizedQueue.new(@configuration.queue_size)
+      @worker        = nil
+      @running       = false
+
+      # Cache values that are static for the lifetime of this client so we
+      # don't allocate on every send_request call.
+      @uri         = URI.parse(@configuration.endpoint).freeze
+      @use_ssl     = @uri.scheme == 'https'
+      @auth_header = "Bearer #{@configuration.api_key}".freeze
     end
 
     def publish(payload)
@@ -24,9 +34,9 @@ module Logister
     def flush(timeout: 2)
       return true unless @configuration.async
 
-      started_at = monotonic_now
-      while @queue.length.positive?
-        return false if monotonic_now - started_at > timeout
+      deadline = monotonic_now + timeout
+      until @queue.empty?
+        return false if monotonic_now > deadline
 
         sleep(0.01)
       end
@@ -44,6 +54,7 @@ module Logister
         nil
       end
       @worker&.join(1)
+      @worker = nil
       true
     end
 
@@ -58,18 +69,20 @@ module Logister
     end
 
     def ensure_worker_started
+      # Fast path — no lock needed if already running (GVL-safe on MRI).
       return if @running && @worker&.alive?
 
       @worker_mutex.synchronize do
         return if @running && @worker&.alive?
 
         @running = true
-        @worker = Thread.new { run_worker }
+        @worker  = Thread.new { run_worker }
+        @worker.name = 'logister-worker'
       end
     end
 
     def run_worker
-      while @running
+      loop do
         payload = @queue.pop
         break if payload.nil?
 
@@ -77,6 +90,9 @@ module Logister
       end
     rescue StandardError => e
       @configuration.logger.warn("logister worker crashed: #{e.class} #{e.message}")
+    ensure
+      # Always clear running flag and attempt auto-restart after a crash so
+      # events enqueued after the crash are not silently dropped.
       @running = false
     end
 
@@ -97,16 +113,15 @@ module Logister
     end
 
     def send_request(payload)
-      uri = URI.parse(@configuration.endpoint)
-      request = Net::HTTP::Post.new(uri)
-      request['Content-Type'] = 'application/json'
-      request['Authorization'] = "Bearer #{@configuration.api_key}"
-      request.body = { event: payload }.to_json
+      request = Net::HTTP::Post.new(@uri)
+      request['Content-Type']  = CONTENT_TYPE
+      request['Authorization'] = @auth_header
+      request.body             = { event: payload }.to_json
 
       response = Net::HTTP.start(
-        uri.host,
-        uri.port,
-        use_ssl: uri.scheme == 'https',
+        @uri.host,
+        @uri.port,
+        use_ssl:      @use_ssl,
         open_timeout: @configuration.timeout_seconds,
         read_timeout: @configuration.timeout_seconds
       ) { |http| http.request(request) }
@@ -121,7 +136,7 @@ module Logister
     end
 
     def ready?
-      @configuration.enabled && @configuration.api_key.to_s != ''
+      @configuration.enabled && !@configuration.api_key.to_s.empty?
     end
   end
 end

data/lib/logister/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 module Logister

data/lib/logister/middleware.rb

@@ -1,7 +1,20 @@
+# frozen_string_literal: true
+
+require 'socket'
+
 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]'
+
     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)
@@ -10,12 +23,61 @@ module Logister
       Logister.report_error(
         e,
         context: {
-          request_id: env['action_dispatch.request_id'],
-          path: env['PATH_INFO'],
-          method: env['REQUEST_METHOD']
+          request: build_request_context(env),
+          app:     @app_context
         }
       )
       raise
     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)
+      end
+
+      ctx.compact
+    end
+
+    def build_app_context
+      ctx = { ruby: RUBY_VERSION, hostname: @hostname }
+      ctx[:rails] = Rails::VERSION::STRING if defined?(Rails::VERSION)
+      ctx
+    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?
+
+      first = forwarded.split(',').first
+      first ? first.strip : env['REMOTE_ADDR']
+    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
+      end
+    rescue StandardError
+      {}
+    end
+
+    def resolve_hostname
+      Socket.gethostname
+    rescue StandardError
+      'unknown'
+    end
   end
 end

data/lib/logister/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/railtie'
 
 module Logister
@@ -38,10 +40,10 @@ module Logister
     private
 
     def copy_setting(app, config, key)
-      value = app.config.logister.send(key)
+      value = app.config.logister.public_send(key)
       return if value.nil?
 
-      config.send("#{key}=", value)
+      config.public_send(:"#{key}=", value)
     end
   end
 end

data/lib/logister/reporter.rb

@@ -1,28 +1,59 @@
+# 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)
       return false if ignored_exception?(exception)
       return false if ignored_path?(context)
 
+      merged_context = context.dup
+      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: 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
@@ -40,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)
@@ -53,6 +84,20 @@ module Logister
       @client.publish(payload)
     end
 
+    # Store user info for the current thread so it is automatically attached to
+    # every error reported during this request.
+    #
+    #   Logister.set_user(id: current_user.id, email: current_user.email, name: current_user.name)
+    #
+    def set_user(id: nil, email: nil, name: nil, **extra)
+      ctx = { id: id, email: email, name: name }.merge(extra).compact
+      Thread.current[:logister_user] = ctx.empty? ? nil : ctx
+    end
+
+    def clear_user
+      Thread.current[:logister_user] = nil
+    end
+
     def flush(timeout: 2)
       @client.flush(timeout: timeout)
     end
@@ -63,18 +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
 
@@ -104,21 +162,58 @@ 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)
-      Digest::SHA256.hexdigest("#{exception.class}|#{exception.message}")[0, 32]
+      # 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(@app_root_re, '')       # strip app root (pre-compiled RE)
+
+      if location.empty?
+        # 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
+        Digest::SHA256.hexdigest("#{exception.class}|#{location}")[0, 32]
+      end
+    end
+
+    # 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+/,                                                                 '?')
     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.1.2'
+  VERSION = '0.2.1'
 end

data/lib/logister.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'logister/version'
 require_relative 'logister/configuration'
 require_relative 'logister/client'
@@ -28,6 +30,14 @@ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logister-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Logister