logbrew-sdk 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e89660190354962ae56323ce67dd3192d2b6ac7fc52f73fefe8cca3e4cffe31
-  data.tar.gz: d92f16257ab1911e72f025f0b1fa29a85138e522653a68fdd4466e8f5c0311c7
+  metadata.gz: 23bb3971a708e01fb3baa93461beb30dda7ff5a6d1b807a6f21a2c4365b718ee
+  data.tar.gz: 2254bb2a7317aa32053e43ae2463ba527c8ec4bd9d7147d31a1c085df690857d
 SHA512:
-  metadata.gz: 83d428f770034749b2c6717eb7fae953a21671bd050406822f341e7f06494af15849d1ac58b259ab08c2910f161e7bf8321fa3b3b6867b8bb14b048883b0a684
-  data.tar.gz: b60cd4f0f853c45fd656d16605b23bafa4fd2396f56be9c2be7ba8da3aa358a33510082f0ca49a45222690caea01bc1b5c3997ab30819ada8a8bde311963a617
+  metadata.gz: b516708afcb021d131aac74c02b0dae2b97d04875f45ec408ff431a5046d2c12af0e824ddddbd5e9280c934ed2a016615cabb4e9d035174c2da99e4806afbc14
+  data.tar.gz: '09b94b37beba32a8956b06295ca7ad0b4f16b0de21e1148a127797f1fd61f0c7763dc85b336ee7a8e249dbd38f02e2e878aadb855dc6beb4404584a5ae6b89d4'

data/README.md

@@ -4,7 +4,7 @@
   <img src="https://raw.githubusercontent.com/LogBrewCo/sdk/main/assets/brand/logbrew-logo-transparent-512.png" alt="LogBrew logo" width="96" height="96">
 </p>
 
-Public Ruby SDK for building, validating, previewing, and flushing LogBrew event batches, with automatic Rails request/error capture, standard-library `Net::HTTP` delivery, opt-in standard-library `Logger` support, and manual Rack helpers.
+Public Ruby SDK for building, validating, previewing, and flushing LogBrew event batches, with automatic Rails request, database, cache, view, and error capture; standard-library `Net::HTTP` delivery; opt-in standard-library `Logger` support; and manual Rack helpers.
 
 The core package has no runtime gem dependencies. Its automatic integration
 activates only inside an application that has already loaded Rails.
@@ -23,7 +23,7 @@ needed:
 
 ```ruby
 # Gemfile
-gem "logbrew-sdk", "~> 0.1.6"
+gem "logbrew-sdk", "~> 0.1.8"
 ```
 
 ```bash
@@ -40,8 +40,14 @@ disabled and the application behaves normally. Set `LOGBREW_ENABLED=false` to
 disable it explicitly. If the Gemfile uses `require: false`, load
 `logbrew/rails` yourself after Rails.
 
-The automatic integration records route-template request spans and typed
-exception issues. Escaped request failures include exception identity,
+The automatic integration records route-template request spans and up to eight
+slowest request-local Active Record, Rails cache, and Action View child spans.
+The request span reports exact observed and captured operation counts plus
+truncation. Operation evidence contains only the operation type, duration,
+cache-hit state, relative `app/views` template path, and exception type when
+present. It never contains SQL, cache keys or values, or absolute paths.
+
+Escaped request failures include exception identity,
 `rails.middleware` with `handled: false`, and up to 32 newest-first sanitized
 frames. Handled Rails reports use `rails.error_reporter` with `handled: true`.
 It does not record concrete request paths, query strings, request or response

data/lib/logbrew/operation_tracing.rb

@@ -3,34 +3,10 @@
 module LogBrew
   # Explicit dependency spans for app-owned database, cache, and queue work.
   module OperationTracing
-    UNSAFE_METADATA_PATTERNS = [
-      /authorization/i,
-      /body/i,
-      /broker/i,
-      /cache.?key/i,
-      /command/i,
-      /connection/i,
-      /cookie/i,
-      /dsn/i,
-      /header/i,
-      /host/i,
-      /\bjid\z/i,
-      /job.?id/i,
-      /key/i,
-      /message/i,
-      /param/i,
-      /pass#{'word'}/i,
-      /payload/i,
-      /query/i,
-      /sec#{'ret'}/i,
-      /sql/i,
-      /statement/i,
-      /to#{'ken'}/i,
-      /url/i,
-      /username/i,
-      /value/i
-    ].freeze
-    private_constant :UNSAFE_METADATA_PATTERNS
+    UNSAFE_METADATA = /authorization|body|broker|cache.?key|command|connection|cookie|dsn|header|host|
+      \bjid\z|job.?id|key|message|param|pass#{'word'}|payload|query|sec#{'ret'}|sql|statement|
+      to#{'ken'}|url|username|value/ix
+    private_constant :UNSAFE_METADATA
 
     module_function
 
@@ -70,20 +46,22 @@ module LogBrew
     end
 
     def capture_span(client, kind, name, context, started_at, options, error)
-      client.span(
-        event_id(kind, context, options),
-        timestamp(options),
-        {
-          name: "#{kind}.operation:#{name}",
-          traceId: context.trace_id,
-          spanId: context.span_id,
-          parentSpanId: context.parent_span_id,
-          status: error ? "error" : "ok",
-          durationMs: duration_ms(started_at, options),
-          metadata: span_metadata(kind, options, error),
-          events: span_events(error)
-        }
-      )
+      Trace.with_context(context) do
+        client.span(
+          event_id(kind, context, options),
+          timestamp(options),
+          {
+            name: "#{kind}.operation:#{name}",
+            traceId: context.trace_id,
+            spanId: context.span_id,
+            parentSpanId: context.parent_span_id,
+            status: error ? "error" : "ok",
+            durationMs: duration_ms(started_at, options),
+            metadata: span_metadata(kind, options, error),
+            events: span_events(error)
+          }
+        )
+      end
     rescue StandardError => capture_error
       on_error = read_option(options, :on_error)
       begin
@@ -99,7 +77,7 @@ module LogBrew
 
       Trace.create(
         trace_id: parent.trace_id,
-        span_id: generate_span_id,
+        span_id: Trace.generate_span_id,
         parent_span_id: parent.span_id,
         trace_flags: parent.trace_flags
       )
@@ -107,7 +85,7 @@ module LogBrew
 
     def span_metadata(kind, options, error)
       sanitized_metadata(read_option(options, :metadata)).tap do |metadata|
-        metadata["source"] = "#{kind}.operation"
+        metadata["source"] = read_option(options, :source) || "#{kind}.operation"
         add_option(metadata, "#{kind}.system", read_option(options, :system))
         add_option(metadata, "#{kind}.operation", read_option(options, :operation))
         add_option(metadata, "#{kind}.target", read_option(options, :target))
@@ -137,29 +115,22 @@ module LogBrew
         normalized_key = key.to_s
         next if normalized_key.strip.empty?
         next if unsafe_metadata_key?(normalized_key)
-        next unless primitive_metadata_value?(value)
+        next unless CaptureHelpers.primitive_metadata_value?(value)
 
         copied[normalized_key] = value
       end
     end
 
     def unsafe_metadata_key?(key)
-      UNSAFE_METADATA_PATTERNS.any? { |pattern| key.match?(pattern) }
-    end
-
-    def primitive_metadata_value?(value)
-      return true if value.nil? || value == true || value == false
-      return true if value.is_a?(String) || value.is_a?(Integer)
-
-      value.is_a?(Float) && value.finite?
+      key.match?(UNSAFE_METADATA)
     end
 
     def add_option(metadata, key, value)
-      metadata[key] = value if primitive_metadata_value?(value) && !(value.is_a?(String) && value.strip.empty?)
+      metadata[key] = value if CaptureHelpers.primitive_metadata_value?(value) && !(value.is_a?(String) && value.strip.empty?)
     end
 
     def read_option(options, key)
-      options[key] || options[key.to_s]
+      options.key?(key) ? options[key] : options[key.to_s]
     end
 
     def event_id(kind, context, options)
@@ -184,11 +155,5 @@ module LogBrew
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def generate_span_id
-      loop do
-        value = SecureRandom.hex(8)
-        return value unless value.delete("0").empty?
-      end
-    end
   end
 end

data/lib/logbrew/rails.rb

@@ -77,6 +77,9 @@ module LogBrew
   class RailsRailtie < ::Rails::Railtie
     initializer "logbrew.install", after: :load_config_initializers do |application|
       runtime = LogBrew::Rails.install(application: application)
+      if runtime.configuration.enabled?
+        LogBrew::Rails.const_get(:RequestOperations).install(::ActiveSupport::Notifications)
+      end
       middleware = application.config.middleware
       if defined?(::ActionDispatch::ShowExceptions)
         middleware.insert_after(

data/lib/logbrew/rails_integration.rb

@@ -120,7 +120,6 @@ module LogBrew
         text = value.to_s.strip
         text.empty? ? nil : text
       end
-      private_class_method :optional_text
 
       def self.server_key_value(value)
         text = optional_text(value)
@@ -131,7 +130,6 @@ module LogBrew
 
         text
       end
-      private_class_method :server_key_value
 
       def self.bounded_label(value, label)
         text = optional_text(value)
@@ -142,7 +140,6 @@ module LogBrew
 
         text.freeze
       end
-      private_class_method :bounded_label
 
       def self.optional_bounded_label(value, label)
         text = optional_text(value)
@@ -150,7 +147,6 @@ module LogBrew
 
         bounded_label(text, label)
       end
-      private_class_method :optional_bounded_label
 
       def self.boolean_value(environment, name, default)
         value = optional_text(environment[name])
@@ -163,7 +159,6 @@ module LogBrew
           raise SdkError.new("configuration_error", "#{name} must be true or false")
         end
       end
-      private_class_method :boolean_value
 
       def self.integer_value(environment, name, default, minimum, maximum)
         text = optional_text(environment[name])
@@ -179,7 +174,6 @@ module LogBrew
           "#{name} must be an integer between #{minimum} and #{maximum}"
         )
       end
-      private_class_method :integer_value
 
       def self.endpoint_value(value)
         text = optional_text(value) || DEFAULT_ENDPOINT
@@ -203,7 +197,8 @@ module LogBrew
       rescue URI::InvalidURIError
         raise SdkError.new("configuration_error", "LOGBREW_ENDPOINT must be a valid HTTP URL")
       end
-      private_class_method :endpoint_value
+      private_class_method :optional_text, :server_key_value, :bounded_label,
+                           :optional_bounded_label, :boolean_value, :integer_value, :endpoint_value
 
       def initialize(
         enabled:,
@@ -249,6 +244,7 @@ module LogBrew
 
     # Owns one lazy automatic-delivery client per operating-system process.
     class Runtime
+      include CaptureHelpers
       attr_reader :configuration
 
       def initialize(
@@ -320,6 +316,16 @@ module LogBrew
         nil
       end
 
+      def metadata
+        @metadata ||= {
+          "service" => @configuration.service_name,
+          "environment" => @configuration.app_environment,
+          "framework" => "rails",
+          "framework.version" => @configuration.rails_version,
+          "release" => @configuration.release
+        }.compact.freeze
+      end
+
       private
 
       def prepare_process_state
@@ -372,7 +378,6 @@ module LogBrew
 
       def record_process_context(created)
         timestamp = logbrew_timestamp
-        metadata = base_metadata
         created.environment(
           "ruby_rails_environment_#{SecureRandom.hex(8)}",
           timestamp,
@@ -388,29 +393,84 @@ module LogBrew
           metadata: metadata
         )
       end
+    end
 
-      def base_metadata
-        {
-          "service" => @configuration.service_name,
-          "environment" => @configuration.app_environment,
-          "framework" => "rails",
-          "framework.version" => @configuration.rails_version
-        }
+    # Buffers only the slowest request-local framework operations without raw
+    # SQL, cache keys, absolute paths, or exception messages.
+    module RequestOperations
+      LIMIT = 8
+      STATE_KEY = :logbrew_rails_request_operations
+      EVENTS = /\A(?:(sql)\.active_record|(cache)_(read|write|delete|exist\?|fetch_hit|generate)\.active_support|(render)_(template|partial|collection)\.action_view)\z/
+      private_constant :LIMIT, :STATE_KEY, :EVENTS
+
+      module_function
+
+      def install(notifications)
+        @mutex ||= Mutex.new
+        @mutex.synchronize { @subscription ||= notifications.subscribe(EVENTS) { |*event| record(*event) } }
+      end
+
+      def within
+        previous = Thread.current[STATE_KEY]
+        Thread.current[STATE_KEY] = [0, []]
+        yield
+      ensure
+        Thread.current[STATE_KEY] = previous
+      end
+
+      def record(name, started_at, finished_at, _id = nil, payload = {})
+        state = Thread.current[STATE_KEY]
+        match = EVENTS.match(name.to_s)
+        return if state.nil? || match.nil? || !payload.is_a?(Hash)
+        duration_ms = ((finished_at - started_at) * 1_000).round(3)
+        return unless duration_ms.finite? && !duration_ms.negative?
+        kind, operation = match[1] ? %w[database query] : [match[2] ? "cache" : "view", match[3] || match[5]]
+        metadata = { "rails.notification" => name.to_s }
+        metadata["cache.hit"] = payload[:hit] if kind == "cache" && [true, false].include?(payload[:hit])
+        template = template_path(payload[:identifier]) if kind == "view"
+        metadata["view.template"] = template unless template.nil?
+        error = payload[:exception_object]
+        state[0] += 1
+        timestamp = started_at.iso8601(6) if started_at.respond_to?(:iso8601)
+        timestamp ||= Time.now.utc.iso8601(6)
+        state[1] << [duration_ms, kind, operation, metadata, error.is_a?(Exception) ? error : nil, timestamp, started_at]
+        state[1].sort_by! { |item| [item[0], item[1], item[2]] }
+        state[1].shift if state[1].length > LIMIT
+      rescue StandardError
+        nil
       end
 
-      def logbrew_timestamp
-        timestamp = @timestamp_provider.call
-        return timestamp.iso8601 if timestamp.respond_to?(:iso8601)
+      def snapshot
+        Thread.current[STATE_KEY] || [0, []]
+      end
+
+      def template_path(identifier)
+        text = identifier.to_s.tr("\\", "/")
+        relative = text.split("/app/views/", 2)[1]
+        return if relative.nil? || relative.empty? || relative.bytesize > 255 || relative.match?(/[[:cntrl:]]/) || relative.split("/").include?("..")
 
-        timestamp.to_s
+        relative
       end
+      private_class_method :template_path
     end
+    private_constant :RequestOperations
 
     # Internal Rack adapter that replaces concrete request paths with Rails
     # route templates while reusing the core request/error lifecycle.
     class RailsRackMiddleware < LogBrew::RackMiddleware
       private
 
+      def capture_request_span(*arguments)
+        super.tap do
+          RequestOperations.snapshot[1].sort_by(&:last).each do |duration_ms, kind, name, metadata, error, timestamp|
+            LogBrew::OperationTracing.capture_span(
+              @client, kind, name, LogBrew::OperationTracing.child_context, nil,
+              { duration_ms: duration_ms, timestamp: timestamp, source: "rails.active_support", system: kind == "database" ? "active_record" : "rails", operation: name, metadata: metadata, on_error: @on_error }, error
+            )
+          end
+        end
+      end
+
       def exception_mechanism_type
         "rails.middleware"
       end
@@ -442,17 +502,21 @@ module LogBrew
       end
 
       def request_metadata(env, status_code)
-        metadata = super
-        metadata.delete("http.path")
-        metadata.delete("action_dispatch.request_id")
-        metadata.delete("HTTP_X_REQUEST_ID")
-        metadata["source"] = "rails"
-        metadata["http.route"] = route_template(env)
-        metadata["http.status_class"] = "#{status_code.to_i / 100}xx"
-        controller, action = controller_and_action(env)
-        metadata["rails.controller"] = controller unless controller.nil?
-        metadata["rails.action"] = action unless action.nil?
-        metadata
+        super.tap do |metadata|
+          metadata.delete("http.path")
+          metadata.delete("action_dispatch.request_id")
+          metadata.delete("HTTP_X_REQUEST_ID")
+          metadata["source"] = "rails"
+          metadata["http.route"] = route_template(env)
+          metadata["http.status_class"] = "#{status_code.to_i / 100}xx"
+          controller, action = controller_and_action(env)
+          metadata["rails.controller"] = controller unless controller.nil?
+          metadata["rails.action"] = action unless action.nil?
+          observed, operations = RequestOperations.snapshot
+          metadata["rails.operations.observed"] = observed
+          metadata["rails.operations.captured"] = operations.length
+          metadata["rails.operations.truncated"] = observed > operations.length
+        end
       end
 
       def route_template(env)
@@ -486,8 +550,7 @@ module LogBrew
         parameters = env["action_dispatch.request.path_parameters"]
         return [nil, nil] unless parameters.is_a?(Hash)
 
-        [bounded_identifier(parameters[:controller] || parameters["controller"]),
-         bounded_identifier(parameters[:action] || parameters["action"])]
+        %i[controller action].map { |key| bounded_identifier(parameters[key] || parameters[key.to_s]) }
       end
 
       def bounded_route(value)
@@ -500,12 +563,7 @@ module LogBrew
       end
 
       def bounded_identifier(value)
-        return nil if value.nil?
-
-        identifier = value.to_s
-        return nil unless identifier.match?(/\A[a-zA-Z0-9_\/.-]{1,128}\z/)
-
-        identifier
+        value.to_s[/\A[a-zA-Z0-9_\/.-]{1,128}\z/]
       end
     end
     private_constant :RailsRackMiddleware
@@ -530,7 +588,7 @@ module LogBrew
         adapter = adapter_for(active_client)
         return @app.call(environment) if adapter.nil?
 
-        adapter.call(environment)
+        RequestOperations.within { adapter.call(environment) }
       end
 
       private
@@ -543,7 +601,7 @@ module LogBrew
             @app,
             client: active_client,
             flush_on_response: false,
-            metadata: base_metadata,
+            metadata: @runtime.metadata,
             include_exception_message: @runtime.configuration.capture_exception_messages?,
             include_exception_backtrace: @runtime.configuration.include_exception_backtrace?,
             on_error: ->(error) { @runtime.report_error("request_capture", error) }
@@ -556,17 +614,6 @@ module LogBrew
         nil
       end
 
-      def base_metadata
-        configuration = @runtime.configuration
-        {
-          "service" => configuration.service_name,
-          "environment" => configuration.app_environment,
-          "framework" => "rails",
-          "framework.version" => configuration.rails_version
-        }.tap do |metadata|
-          metadata["release"] = configuration.release unless configuration.release.nil?
-        end
-      end
     end
 
     # Rails.error subscriber for handled reports. Unhandled errors stay owned
@@ -606,18 +653,12 @@ module LogBrew
         @mutex.synchronize do
           return @subscriber if @subscriber_client.equal?(active_client) && !@subscriber.nil?
 
-          configuration = @runtime.configuration
           @subscriber = LogBrew::RailsErrorSubscriber.new(
             client: active_client,
             flush_on_report: false,
-            metadata: {
-              "service" => configuration.service_name,
-              "environment" => configuration.app_environment,
-              "framework" => "rails",
-              "framework.version" => configuration.rails_version
-            },
-            include_exception_message: configuration.capture_exception_messages?,
-            include_exception_backtrace: configuration.include_exception_backtrace?,
+            metadata: @runtime.metadata,
+            include_exception_message: @runtime.configuration.capture_exception_messages?,
+            include_exception_backtrace: @runtime.configuration.include_exception_backtrace?,
             on_error: ->(error) { @runtime.report_error("handled_error_capture", error) }
           )
           @subscriber_client = active_client

data/lib/logbrew/trace.rb

@@ -240,7 +240,7 @@ module LogBrew
 
     private
 
-    def capture_request_span(env, status_code, elapsed_ms, status)
+    def capture_request_span(env, status_code, elapsed_ms, status, timestamp)
       context = rack_trace_context(env)
       attributes = {
         name: request_name(env),
@@ -252,31 +252,21 @@ module LogBrew
       }
       attributes[:parentSpanId] = context.parent_span_id if context && context.parent_span_id
 
-      @client.span(next_event_id("span"), logbrew_timestamp, attributes)
+      @client.span(next_event_id("span"), timestamp, attributes)
     end
 
     def trace_id(env)
-      context = rack_trace_context(env)
-      return context.trace_id if context
-
-      super
+      rack_trace_context(env)&.trace_id || super
     end
 
     def span_id(env)
-      context = rack_trace_context(env)
-      return context.span_id if context
-
-      super
+      rack_trace_context(env)&.span_id || super
     end
 
     def request_metadata(env, status_code)
       Trace.add_metadata(super, rack_trace_context(env))
     end
 
-    def exception_metadata(env, error)
-      Trace.add_metadata(super, rack_trace_context(env))
-    end
-
     def rack_trace_context(env)
       trace = env["logbrew.trace"] if env.respond_to?(:[])
       trace.is_a?(TraceContext) ? trace : Trace.current

data/lib/logbrew/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LogBrew
-  VERSION = "0.1.6"
+  VERSION = "0.1.8"
 end

data/lib/logbrew.rb

@@ -33,6 +33,32 @@ module LogBrew
   METRIC_KINDS = METRIC_TEMPORALITIES_BY_KIND.keys.freeze
   NON_NEGATIVE_METRIC_KINDS = %w[counter histogram].freeze
 
+  module CaptureHelpers
+    module_function
+
+    def primitive_metadata_value?(value)
+      value.nil? || value == true || value == false || value.is_a?(String) || value.is_a?(Integer) ||
+        (value.is_a?(Float) && value.finite?)
+    end
+
+    def copy_metadata(metadata)
+      metadata.each_with_object({}) { |(key, value), copied| copied[key.to_s] = value if primitive_metadata_value?(value) }
+    end
+
+    def logbrew_timestamp(precision = nil)
+      timestamp = @timestamp_provider.respond_to?(:call) ? @timestamp_provider.call : Time.now
+      timestamp.respond_to?(:iso8601) ? timestamp.iso8601(*[precision].compact) : timestamp.to_s
+    end
+
+    def capture_safely
+      yield
+    rescue StandardError => error
+      @on_error.call(error) if @on_error.respond_to?(:call)
+      raise error if @raise_errors
+    end
+  end
+  private_constant :CaptureHelpers
+
   class SdkError < StandardError
     attr_reader :code
 
@@ -202,6 +228,7 @@ module LogBrew
   end
 
   class Logger < ::Logger
+    include CaptureHelpers
     DEFAULT_LOGGER_NAME = "ruby-logger"
     SEVERITY_TO_LOGBREW_LEVEL = {
       ::Logger::DEBUG => "info",
@@ -306,13 +333,6 @@ module LogBrew
       raise error if @raise_errors
     end
 
-    def logbrew_timestamp
-      timestamp = @timestamp_provider.respond_to?(:call) ? @timestamp_provider.call : Time.now
-      return timestamp.iso8601 if timestamp.respond_to?(:iso8601)
-
-      timestamp.to_s
-    end
-
     def logbrew_message(message)
       return message.message if message.is_a?(Exception)
       return message if message.is_a?(String)
@@ -347,18 +367,6 @@ module LogBrew
       metadata["exceptionBacktrace"] = exception.backtrace.join("\n") if @include_exception_backtrace && exception.backtrace
     end
 
-    def copy_metadata(metadata)
-      metadata.each_with_object({}) do |(key, value), copied|
-        copied[key.to_s] = value if primitive_metadata_value?(value)
-      end
-    end
-
-    def primitive_metadata_value?(value)
-      return true if value.nil? || value == true || value == false
-      return true if value.is_a?(String) || value.is_a?(Integer)
-
-      value.is_a?(Float) && value.finite?
-    end
   end
   # Rack-compatible middleware for Rails, Sinatra, and other Rack-based Ruby apps.
   #
@@ -366,6 +374,7 @@ module LogBrew
   # exceptions as issue plus error-span events. It does not require the rack or
   # rails gems at runtime; any app object that responds to `call(env)` is enough.
   class RackMiddleware
+    include CaptureHelpers
     DEFAULT_EVENT_ID_PREFIX = "ruby_rack"
     DEFAULT_SPAN_LOGGER = "rack"
 
@@ -403,36 +412,42 @@ module LogBrew
 
     def call(env)
       started_at = monotonic_time
-      begin
-        response = @app.call(env)
+      started_timestamp, timestamp_error = request_timestamp
+      response = begin
+        @app.call(env)
       rescue StandardError => error
-        status_code = exception_status_code(error)
-        safely_capture do
-          capture_exception_issue(env, error) if status_code >= 500
-          capture_request_span(env, status_code, duration_ms(started_at), status_code >= 500 ? "error" : "ok")
-          flush_if_configured
-        end
+        capture_request(env, exception_status_code(error), started_at, started_timestamp, timestamp_error, error)
         raise
       end
+      capture_request(env, rack_status(response), started_at, started_timestamp, timestamp_error)
+      response
+    end
 
-      status_code = rack_status(response)
-      safely_capture do
-        capture_request_span(env, status_code, duration_ms(started_at), status_code >= 500 ? "error" : "ok")
+    private
+
+    def capture_request(env, status_code, started_at, timestamp, timestamp_error, error = nil)
+      capture_safely do
+        raise timestamp_error unless timestamp_error.nil?
+        capture_exception_issue(env, error, logbrew_timestamp(6)) if error && status_code >= 500
+        capture_request_span(env, status_code, duration_ms(started_at), status_code >= 500 ? "error" : "ok", timestamp)
         flush_if_configured
       end
-      response
     end
 
-    private
+    def request_timestamp
+      [logbrew_timestamp(6), nil]
+    rescue StandardError => error
+      [nil, error]
+    end
 
     def exception_status_code(_error)
       500
     end
 
-    def capture_request_span(env, status_code, elapsed_ms, status)
+    def capture_request_span(env, status_code, elapsed_ms, status, timestamp)
       @client.span(
         next_event_id("span"),
-        logbrew_timestamp,
+        timestamp,
         name: request_name(env),
         traceId: trace_id(env),
         spanId: span_id(env),
@@ -442,7 +457,7 @@ module LogBrew
       )
     end
 
-    def capture_exception_issue(env, error)
+    def capture_exception_issue(env, error, timestamp)
       attributes = IssueDiagnostics.from_exception(
         error,
         message: @include_exception_message ? error.message : nil,
@@ -450,7 +465,7 @@ module LogBrew
         handled: false,
         metadata: exception_metadata(env, error)
       )
-      @client.issue(next_event_id("issue"), logbrew_timestamp, attributes)
+      @client.issue(next_event_id("issue"), timestamp, attributes)
     end
 
     def next_event_id(kind)
@@ -460,13 +475,6 @@ module LogBrew
       end
     end
 
-    def logbrew_timestamp
-      timestamp = @timestamp_provider.respond_to?(:call) ? @timestamp_provider.call : Time.now
-      return timestamp.iso8601 if timestamp.respond_to?(:iso8601)
-
-      timestamp.to_s
-    end
-
     def request_name(env)
       "#{request_method(env)} #{request_path(env)}"
     end
@@ -562,19 +570,6 @@ module LogBrew
       metadata[key] = value unless value.nil?
     end
 
-    def copy_metadata(metadata)
-      metadata.each_with_object({}) do |(key, value), copied|
-        copied[key.to_s] = value if primitive_metadata_value?(value)
-      end
-    end
-
-    def primitive_metadata_value?(value)
-      return true if value.nil? || value == true || value == false
-      return true if value.is_a?(String) || value.is_a?(Integer)
-
-      value.is_a?(Float) && value.finite?
-    end
-
     def monotonic_time
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
@@ -589,12 +584,6 @@ module LogBrew
       @client.flush(@transport)
     end
 
-    def safely_capture
-      yield
-    rescue StandardError => error
-      @on_error.call(error) if @on_error.respond_to?(:call)
-      raise error if @raise_errors
-    end
   end
 
   # Rails.error subscriber for handled and manually reported Rails exceptions.
@@ -603,6 +592,7 @@ module LogBrew
   # initializer. This class avoids a hard Rails dependency so the core gem stays
   # usable in plain Ruby and Rack apps.
   class RailsErrorSubscriber
+    include CaptureHelpers
     DEFAULT_EVENT_ID_PREFIX = "ruby_rails_error"
     SEVERITY_TO_ISSUE_LEVEL = {
       "info" => "info",
@@ -667,13 +657,6 @@ module LogBrew
 
     private
 
-    def logbrew_timestamp
-      timestamp = @timestamp_provider.respond_to?(:call) ? @timestamp_provider.call : Time.now
-      return timestamp.iso8601 if timestamp.respond_to?(:iso8601)
-
-      timestamp.to_s
-    end
-
     def error_title(error)
       return error.class.name if error.is_a?(Exception)
 
@@ -743,31 +726,12 @@ module LogBrew
       "rails-exception-#{Digest::SHA256.hexdigest(material)}"
     end
 
-    def copy_metadata(metadata)
-      metadata.each_with_object({}) do |(key, value), copied|
-        copied[key.to_s] = value if primitive_metadata_value?(value)
-      end
-    end
-
-    def primitive_metadata_value?(value)
-      return true if value.nil? || value == true || value == false
-      return true if value.is_a?(String) || value.is_a?(Integer)
-
-      value.is_a?(Float) && value.finite?
-    end
-
     def flush_if_configured
       return unless @flush_on_report && !@transport.nil? && @client.pending_events.positive?
 
       @client.flush(@transport)
     end
 
-    def capture_safely
-      yield
-    rescue StandardError => error
-      @on_error.call(error) if @on_error.respond_to?(:call)
-      raise error if @raise_errors
-    end
   end
 
   module Validation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logbrew-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - LogBrew
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-11 00:00:00.000000000 Z
+date: 2026-08-13 00:00:00.000000000 Z
 dependencies: []
 description: Public LogBrew Ruby SDK with typed issue diagnostics, automatic Rails
   request/error capture, and standard-library delivery.