logbrew-sdk 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb21d5bb9dcb7781c910e2b7ba05b27c15a6c43d6d8d309dbd9349646530a9e3
-  data.tar.gz: 01b26764ad7ff0b40e75649ae1481a6697e4b2811bf5ac10a72df7b7fb2b2eaa
+  metadata.gz: f086729efb0a0a98821ef3bce8d96b71066b202beff5656917d958e4ca119479
+  data.tar.gz: 7c5eafb18cda7d001dc8c72c9646852e857a46bd4e06508abeda5a23365489a1
 SHA512:
-  metadata.gz: dcaa0c49f1305d004f66605e07e9bc552f02dab4feca7a18fff90f34d02899b58661c1b5f786b75719f2368fe2dcd080cc2b3c7a95037b423bab52b2d3386f0d
-  data.tar.gz: a4bc7c482321d08c040d2b815454e70382a45d73ade264025855a1f4a06fc9d0b48c69a540e21f2dd21e26379f320cc76ba80d98c7a207bbd0592e149d093a99
+  metadata.gz: 583a7cdc7ccc4ea1435a31454c0d90cea390a7b9f37e1322c3f39bc84bf0b2c731aaa08abff5384675871f62082fd8fc98c5c2c7284ad89a1fb6c9b1221982e0
+  data.tar.gz: 5093fb1d5ea5540302c6a99c8d6fa7ce1b66142a55010c7d867e1f0539d1fe57525270486c59e58acd687a68bb51e44aaa62f480a3c119681648d9a876d70fbb

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.5"
+gem "logbrew-sdk", "~> 0.1.7"
 ```
 
 ```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 snapshot
+        Thread.current[STATE_KEY] || [0, []]
       end
 
-      def logbrew_timestamp
-        timestamp = @timestamp_provider.call
-        return timestamp.iso8601 if timestamp.respond_to?(:iso8601)
+      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
@@ -419,6 +479,15 @@ module LogBrew
         "rails-exception"
       end
 
+      def exception_status_code(error)
+        return super unless defined?(::ActionDispatch::ExceptionWrapper)
+
+        status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(error.class.name)
+        status.is_a?(Integer) && status.between?(400, 599) ? status : super
+      rescue StandardError
+        super
+      end
+
       def request_name(env)
         "#{request_method(env)} #{route_template(env)}"
       end
@@ -433,26 +502,26 @@ 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.method"] = request_method(env)
-        metadata["http.route"] = route_template(env)
-        metadata["http.status_code"] = status_code
-        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)
-        route = bounded_route(env_value(env, "action_dispatch.route_uri_pattern"))
-        return route unless route.nil?
-
-        route = bounded_route(matched_route_pattern(env))
+        route = bounded_route(env_value(env, "action_dispatch.route_uri_pattern")) ||
+                bounded_route(matched_route_pattern(env))
         return route unless route.nil?
 
         controller, action = controller_and_action(env)
@@ -481,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)
@@ -495,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
@@ -525,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
@@ -538,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) }
@@ -551,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
@@ -601,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LogBrew
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 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
+      timestamp = @timestamp_provider.respond_to?(:call) ? @timestamp_provider.call : Time.now
+      timestamp.respond_to?(:iso8601) ? timestamp.iso8601 : 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"
 
@@ -406,17 +415,17 @@ module LogBrew
       begin
         response = @app.call(env)
       rescue StandardError => error
-        safely_capture do
-          elapsed_ms = duration_ms(started_at)
-          capture_exception_issue(env, error)
-          capture_request_span(env, 500, elapsed_ms, "error")
+        status_code = exception_status_code(error)
+        capture_safely 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
         raise
       end
 
       status_code = rack_status(response)
-      safely_capture do
+      capture_safely do
         capture_request_span(env, status_code, duration_ms(started_at), status_code >= 500 ? "error" : "ok")
         flush_if_configured
       end
@@ -425,6 +434,10 @@ module LogBrew
 
     private
 
+    def exception_status_code(_error)
+      500
+    end
+
     def capture_request_span(env, status_code, elapsed_ms, status)
       @client.span(
         next_event_id("span"),
@@ -456,13 +469,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
@@ -558,19 +564,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
@@ -585,12 +578,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.
@@ -599,6 +586,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",
@@ -663,13 +651,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)
 
@@ -739,31 +720,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.5
+  version: 0.1.7
 platform: ruby
 authors:
 - LogBrew
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-10 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.