logister-ruby 0.5.1 → 0.6.0

data/lib/logister/reporter.rb

@@ -2,7 +2,6 @@
 
 require 'digest'
 require 'time'
-require 'set'
 require 'securerandom'
 require_relative 'context_helpers'
 require_relative 'context_store'
@@ -35,12 +34,6 @@ module Logister
       # 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)
@@ -67,6 +60,8 @@ module Logister
       return false unless payload
 
       @client.publish(payload)
+    rescue StandardError => e
+      internal_failure(e)
     end
 
     def report_metric(message:, value: nil, unit: nil, level: 'info', context: {}, tags: {}, fingerprint: nil)
@@ -99,6 +94,8 @@ module Logister
       return false unless payload
 
       @client.publish(payload)
+    rescue StandardError => e
+      internal_failure(e)
     end
 
     def report_transaction(name:, duration_ms:, level: 'info', context: {}, tags: {}, fingerprint: nil, status: nil)
@@ -123,6 +120,8 @@ module Logister
       return false unless payload
 
       @client.publish(payload)
+    rescue StandardError => e
+      internal_failure(e)
     end
 
     def report_span(
@@ -186,6 +185,8 @@ module Logister
       return false unless payload
 
       @client.publish(payload)
+    rescue StandardError => e
+      internal_failure(e)
     end
 
     def report_log(message:, level: 'info', context: {}, tags: {}, fingerprint: nil)
@@ -205,6 +206,8 @@ module Logister
       return false unless payload
 
       @client.publish(payload)
+    rescue StandardError => e
+      internal_failure(e)
     end
 
     def report_check_in(
@@ -245,6 +248,8 @@ module Logister
       return false unless payload
 
       @client.publish(payload)
+    rescue StandardError => e
+      internal_failure(e)
     end
 
     def record_deployment(
@@ -281,20 +286,24 @@ module Logister
       }.compact
 
       @client.publish_deployment(payload)
+    rescue StandardError => e
+      internal_failure(e)
     end
 
-    # Store user info for the current thread so it is automatically attached to
-    # every error reported during this request.
+    # Store user info in the current request scope so it is attached to every
+    # error reported during this request or job. The middleware and Active Job
+    # integration reset the scope, so identity never carries to the next unit of
+    # work on a reused thread.
     #
     #   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
+      Logister::ContextStore.user = ctx.empty? ? nil : ctx
     end
 
     def clear_user
-      Thread.current[:logister_user] = nil
+      Logister::ContextStore.user = nil
     end
 
     def flush(timeout: 2)
@@ -311,18 +320,13 @@ 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 }
+    def current_user_context
+      Logister::ContextStore.user
     end
 
-    def current_user_context
-      Thread.current[:logister_user]
+    def internal_failure(error)
+      Logister.log_internal_error('report', error)
+      false
     end
 
     def default_error_context
@@ -335,7 +339,7 @@ module Logister
           .merge(Logister::ContextHelpers.deployment_context)
       )
     rescue StandardError => e
-      @configuration.logger.warn("logister default error context failed: #{e.class} #{e.message}")
+      Logister.log_internal_error('default error context', e)
       {}
     end
 
@@ -360,7 +364,7 @@ module Logister
         # 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(Logister::ContextStore.trace_context&.to_h || {}).merge(context)
+        context:     @static_context.merge(Logister::ContextStore.trace_context.to_h).merge(context)
       }
     end
 
@@ -377,7 +381,7 @@ module Logister
 
       result
     rescue StandardError => e
-      @configuration.logger.warn("logister before_notify failed: #{e.class} #{e.message}")
+      Logister.log_internal_error('before_notify', e)
       nil
     end
 

data/lib/logister/request_subscriber.rb

@@ -1,5 +1,3 @@
-require "logger"
-
 module Logister
   class RequestSubscriber
     IGNORED_SQL_NAMES = %w[SCHEMA TRANSACTION].freeze
@@ -57,7 +55,7 @@ module Logister
 
         report_request_span(payload, request_id) if capture_request_spans?
       rescue StandardError => e
-        logger.warn("logister request subscriber (process_action) failed: #{e.class} #{e.message}")
+        Logister.log_internal_error("request subscriber (process_action)", e)
       end
 
       def report_request_span(payload, request_id)
@@ -110,11 +108,11 @@ module Logister
           message: "#{sql_name} query",
           data: {
             durationMs: duration_ms,
-            sql: payload[:sql].to_s[0, 250]
+            sql: Logister::Redaction.strip_sql_literals(payload[:sql])[0, 250]
           }
         )
       rescue StandardError => e
-        logger.warn("logister request subscriber (sql breadcrumb) failed: #{e.class} #{e.message}")
+        Logister.log_internal_error("request subscriber (sql breadcrumb)", e)
       end
 
       def numeric(value)
@@ -136,12 +134,6 @@ module Logister
       rescue StandardError
         false
       end
-
-      def logger
-        configuration&.logger || Logger.new($stdout)
-      rescue StandardError
-        Logger.new($stdout)
-      end
     end
   end
 end

data/lib/logister/sql_subscriber.rb

@@ -53,14 +53,14 @@ module Logister
           context: {
             duration_ms: duration_ms.round(2),
             name:        sql_name,
-            sql:         payload[:sql].to_s,
+            sql:         Logister::Redaction.strip_sql_literals(payload[:sql]),
             cached:      false,
             binds_count: (payload[:binds] || []).size
           },
           tags: TAGS
         )
       rescue StandardError => e
-        config.logger.warn("logister sql subscriber failed: #{e.class} #{e.message}")
+        Logister.log_internal_error('sql subscriber', e)
       end
 
       def sampled_out?(sample_rate)

data/lib/logister/version.rb

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

data/lib/logister.rb

@@ -1,5 +1,8 @@
+require 'active_support/core_ext/object/blank'
 require_relative 'logister/version'
 require_relative 'logister/configuration'
+require_relative 'logister/redaction'
+require_relative 'logister/event_sanitizer'
 require_relative 'logister/reporting_scope'
 require_relative 'logister/client'
 require_relative 'logister/reporter'
@@ -26,12 +29,18 @@ module Logister
       @configuration ||= Configuration.new
     end
 
+    # Reconfiguring replaces the reporter. The previous client drains what it
+    # already queued and stops, so repeated calls never leave idle workers.
     def configure
       yield(configuration)
+      previous = @reporter
       @reporter = nil
+      safely(nil) { previous&.shutdown }
+      register_shutdown_hook
     end
 
     def reporter
+      register_shutdown_hook
       @reporter ||= Reporter.new(configuration)
     end
 
@@ -44,64 +53,102 @@ module Logister
     end
 
     def report_error(exception, **kwargs)
-      reporter.report_error(exception, **kwargs)
+      safely { reporter.report_error(exception, **kwargs) }
     end
 
     def report_metric(**kwargs)
-      reporter.report_metric(**kwargs)
+      safely { reporter.report_metric(**kwargs) }
     end
 
     def report_transaction(**kwargs)
-      reporter.report_transaction(**kwargs)
+      safely { reporter.report_transaction(**kwargs) }
     end
 
     def report_span(**kwargs)
-      reporter.report_span(**kwargs)
+      safely { reporter.report_span(**kwargs) }
     end
 
     def report_log(**kwargs)
-      reporter.report_log(**kwargs)
+      safely { reporter.report_log(**kwargs) }
     end
 
     def report_check_in(**kwargs)
-      reporter.report_check_in(**kwargs)
+      safely { reporter.report_check_in(**kwargs) }
     end
 
     def record_deployment(**kwargs)
-      reporter.record_deployment(**kwargs)
+      safely { reporter.record_deployment(**kwargs) }
+    end
+
+    # Attaches user identity to errors reported in the current request or job.
+    # The Rack middleware and Active Job integration clear it when the request
+    # or job ends; call clear_user yourself in other long-lived threads.
+    def set_user(**kwargs)
+      safely(nil) { reporter.set_user(**kwargs) }
+    end
+
+    def clear_user
+      safely(nil) { reporter.clear_user }
     end
 
     def flush(timeout: 2)
-      reporter.flush(timeout: timeout)
+      safely { reporter.flush(timeout: timeout) }
     end
 
     def delivery_stats
-      reporter.delivery_stats
+      safely({}) { reporter.delivery_stats }
     end
 
     def shutdown
-      reporter.shutdown
+      safely { reporter.shutdown }
     end
 
     def add_breadcrumb(category:, message:, data: {}, level: "info")
-      ContextStore.add_manual_breadcrumb(
-        category: category,
-        message: message,
-        data: data,
-        level: level
-      )
+      safely(nil) do
+        ContextStore.add_manual_breadcrumb(
+          category: category,
+          message: message,
+          data: data,
+          level: level
+        )
+      end
     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
-      )
+      safely(nil) do
+        ContextStore.add_manual_dependency(
+          name: name,
+          host: host,
+          method: method,
+          status: status,
+          duration_ms: duration_ms,
+          kind: kind,
+          data: data
+        )
+      end
+    end
+
+    # Telemetry must never raise into the host application.
+    def log_internal_error(label, error)
+      configuration.logger&.warn("logister #{label} failed: #{error.class}")
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    def safely(fallback = false)
+      yield
+    rescue StandardError => e
+      log_internal_error('call', e)
+      fallback
+    end
+
+    def register_shutdown_hook
+      return if @shutdown_hook_registered
+
+      @shutdown_hook_registered = true
+      at_exit { safely(nil) { @reporter&.shutdown } }
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: logister-ruby
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Logister
 bindir: bin
 cert_chain: []
-date: 2026-09-26 00:00:00.000000000 Z
+date: 2026-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -123,8 +123,10 @@ files:
 - lib/logister/configuration.rb
 - lib/logister/context_helpers.rb
 - lib/logister/context_store.rb
+- lib/logister/event_sanitizer.rb
 - lib/logister/middleware.rb
 - lib/logister/railtie.rb
+- lib/logister/redaction.rb
 - lib/logister/reporter.rb
 - lib/logister/reporting_scope.rb
 - lib/logister/request_subscriber.rb