logbrew-sdk 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ed4c09b597bf3b6c6d2a9426c378c1ef86c3ad32b141cdbf8782d0477ba41d6
-  data.tar.gz: aae266ff513452aa9adc3e48d53ff117aa9ea80bbd6d5dd3ed35da05db2cbb9c
+  metadata.gz: a0af4b97ef8e2b7c4e89c4c7541e1a512d85f4d8aa6e3d87639551145f99875c
+  data.tar.gz: eaa3d1ff11b605c3547964918cfb37714e8ea737c72748f02d08ce2b27fed221
 SHA512:
-  metadata.gz: 8ba3ea392a5a0f56cd7ab4f2c7a23271424149b9fcf8eaa0527b7002403069f9368f08729531b70f4e1c98390a261f544f61f540f95b1f65bfcb0e165ad5df1f
-  data.tar.gz: e0d0b0c6f19fd4c14b1ade31e6e23f31f80928e2faeeb34875fc65ad15e1784a6fe5830e59b958f8650b09cc64965f00235e5ea83f35407a828b00f7a93d3798
+  metadata.gz: fc95d14c11974aa1c83adefa37beb10864029e9d6c5e518c9dccd99ad1901974aa6fa3885a186ad05a00ae23e12642e61f578bec7f1a78d7629dcbf0e4d022dc
+  data.tar.gz: 2154ac935379e496a6d8888058ee22964ad7cda7449ed0af86120f5099656a52f7be54042117f650e66259c848e435df8150f70f3f38ff07e856e6f1cafd3fbc

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, database, cache, view, error, ActiveJob, and outbound `Net::HTTP` capture; standard-library 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, error, ActiveJob, and outbound `Net::HTTP` capture; trace-correlated Rails application logs by explicit opt-in; standard-library 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.10"
+gem "logbrew-sdk", "~> 0.1.12"
 ```
 
 ```bash
@@ -70,6 +70,15 @@ need no initializer. They propagate one W3C child and record only method,
 normalized host, status, duration, adapter source, sampled state, and exception
 type. Calls outside an active trace remain exact pass-throughs.
 
+Set `LOGBREW_CAPTURE_RAILS_LOGS=true` to add application-owned `Rails.logger`
+messages to the active request or ActiveJob trace. The adapter keeps the app's
+configured logger, output, level, return value, and lazy block behavior intact.
+It captures only calls originating from files below `Rails.root`; framework,
+gem, startup, and out-of-trace logs remain local. Messages are limited to 2,048
+characters and include `messageState: captured` or `messageState: truncated`.
+Log messages are application-provided telemetry and can contain sensitive
+values, so enable this only after the application applies its normal filtering.
+
 The explicit Rails capture settings are:
 
 | Environment variable | Default | Purpose |
@@ -84,6 +93,7 @@ The explicit Rails capture settings are:
 | `LOGBREW_FLUSH_INTERVAL_MS` | `5000` | Automatic delivery interval from 10 to 3600000 ms |
 | `LOGBREW_FLUSH_THRESHOLD` | `100` | Queue size from 1 to 1000 that requests an earlier flush |
 | `LOGBREW_CAPTURE_EXCEPTION_MESSAGES` | `false` | Opt in to exception message capture |
+| `LOGBREW_CAPTURE_RAILS_LOGS` | `false` | Opt in to bounded application-origin logs on active request and job traces |
 | `LOGBREW_INCLUDE_EXCEPTION_BACKTRACE` | `false` | Opt in to raw exception backtrace text; sanitized structured frames are always captured |
 
 `LOGBREW_API_KEY` and `LOGBREW_INGEST_KEY` are not Rails aliases. If either is

data/lib/logbrew/http_client_tracing.rb

@@ -19,6 +19,7 @@ module LogBrew
       @method = HttpClientTracing.normalize_method(method)
       @host = HttpClientTracing.normalize_host(host)
       @on_capture_error = on_capture_error
+      @timestamp = Time.now.utc.iso8601(6)
       @started_at = HttpClientTracing.monotonic_time
       @mutex = Mutex.new
       @finished = false
@@ -60,7 +61,7 @@ module LogBrew
 
       @client.span(
         "ruby_http_span_#{@context.span_id}",
-        Time.now.utc.iso8601,
+        @timestamp,
         {
           name: "http.client:#{@method}",
           traceId: @context.trace_id,

data/lib/logbrew/rails.rb

@@ -98,6 +98,7 @@ module LogBrew
       runtime = LogBrew::Rails.runtime
       next if runtime.nil? || !runtime.configuration.enabled?
 
+      LogBrew::Rails.const_get(:ApplicationLogCapture).install(::Rails.logger, runtime, application_root: ::Rails.root)
       reporter = LogBrew::Rails::ErrorReporter.new(runtime)
       if ::Rails.respond_to?(:error) && ::Rails.error.respond_to?(:subscribe)
         ::Rails.error.subscribe(reporter)

data/lib/logbrew/rails_integration.rb

@@ -18,17 +18,13 @@ module LogBrew
       MAX_ENDPOINT_BYTES = 2_048
       LOOPBACK_HOSTS = %w[localhost 127.0.0.1 ::1 [::1]].freeze
 
-      attr_reader(
-        :api_key,
-        :service_name,
-        :app_environment,
-        :rails_version,
-        :release,
-        :endpoint,
-        :request_timeout,
-        :flush_interval,
-        :flush_threshold
-      )
+      ATTRIBUTES = %i[
+        enabled api_key service_name app_environment rails_version release endpoint
+        request_timeout flush_interval flush_threshold capture_exception_messages
+        capture_rails_logs include_exception_backtrace
+      ].freeze
+      private_constant :ATTRIBUTES
+      attr_reader(*ATTRIBUTES.drop(1).reject { |name| name.to_s.start_with?("capture_", "include_") })
 
       def self.from_environment(environment, application_name:, rails_environment:, rails_version:)
         unless environment.respond_to?(:[]) && environment.respond_to?(:key?)
@@ -92,6 +88,7 @@ module LogBrew
             "LOGBREW_CAPTURE_EXCEPTION_MESSAGES",
             false
           ),
+          capture_rails_logs: boolean_value(environment, "LOGBREW_CAPTURE_RAILS_LOGS", false),
           include_exception_backtrace: boolean_value(
             environment,
             "LOGBREW_INCLUDE_EXCEPTION_BACKTRACE",
@@ -113,6 +110,7 @@ module LogBrew
           flush_interval: DEFAULT_FLUSH_INTERVAL_MS / 1_000.0,
           flush_threshold: DEFAULT_FLUSH_THRESHOLD,
           capture_exception_messages: false,
+          capture_rails_logs: false,
           include_exception_backtrace: false
         )
       end
@@ -203,32 +201,11 @@ module LogBrew
       private_class_method :optional_text, :server_key_value, :bounded_label,
                            :optional_bounded_label, :boolean_value, :integer_value, :endpoint_value
 
-      def initialize(
-        enabled:,
-        api_key:,
-        service_name:,
-        app_environment:,
-        rails_version:,
-        release:,
-        endpoint:,
-        request_timeout:,
-        flush_interval:,
-        flush_threshold:,
-        capture_exception_messages:,
-        include_exception_backtrace:
-      )
-        @enabled = enabled
-        @api_key = api_key&.dup&.freeze
-        @service_name = service_name
-        @app_environment = app_environment
-        @rails_version = rails_version
-        @release = release
-        @endpoint = endpoint
-        @request_timeout = request_timeout
-        @flush_interval = flush_interval
-        @flush_threshold = flush_threshold
-        @capture_exception_messages = capture_exception_messages
-        @include_exception_backtrace = include_exception_backtrace
+      def initialize(**attributes)
+        raise ArgumentError, "Rails configuration attributes do not match" unless attributes.keys.sort == ATTRIBUTES.sort
+
+        ATTRIBUTES.each { |name| instance_variable_set("@#{name}", attributes.fetch(name)) }
+        @api_key = @api_key&.dup&.freeze
         freeze
       end
 
@@ -240,6 +217,10 @@ module LogBrew
         @capture_exception_messages
       end
 
+      def capture_rails_logs?
+        @capture_rails_logs
+      end
+
       def include_exception_backtrace?
         @include_exception_backtrace
       end
@@ -398,6 +379,145 @@ module LogBrew
       end
     end
 
+    # Adds one bounded, trace-aware LogBrew sink without replacing the app logger.
+    module ApplicationLogCapture
+      MAX_MESSAGE_CHARACTERS = 2_048
+      SINK_IVAR = :@logbrew_rails_log_sink
+      ROOT_IVAR = :@logbrew_rails_application_root
+      GUARD_KEY = :logbrew_rails_log_capture
+      ORIGIN_KEY = :logbrew_rails_log_origin
+      LIBRARY_ROOT = File.expand_path("..", __dir__)
+      LOGGER_PATH = ::Logger.instance_method(:add).source_location&.first
+      LOGGER_WRAPPER_PATH = %r{/active_support/(?:broadcast_logger|tagged_logging|logger(?:_silence|_thread_safe_level)?)\.rb\z}
+      GEM_ROOTS = (defined?(::Gem) ? ::Gem.path : []).map { |root| "#{File.expand_path(root)}#{File::SEPARATOR}" }.freeze
+      LEVELS = LogBrew::Logger::SEVERITY_TO_LOGBREW_LEVEL
+      private_constant :MAX_MESSAGE_CHARACTERS, :SINK_IVAR, :ROOT_IVAR, :GUARD_KEY, :ORIGIN_KEY,
+                       :LIBRARY_ROOT, :LOGGER_PATH, :LOGGER_WRAPPER_PATH, :GEM_ROOTS, :LEVELS
+
+      class Sink < ::Logger
+        def initialize(runtime, application_root, level)
+          @runtime = runtime
+          @application_root = File.expand_path(application_root.to_s)
+          super(File::NULL)
+          self.level = level
+        end
+
+        def add(severity, message = nil, progname = nil)
+          severity ||= ::Logger::UNKNOWN
+          return true if severity < level
+
+          resolved = message.nil? ? (block_given? ? yield : progname) : message
+          ApplicationLogCapture.capture(@runtime, @application_root, severity, resolved)
+          true
+        end
+      end
+      private_constant :Sink
+
+      module LoggerTap
+        def add(severity, message = nil, progname = nil, &block)
+          severity ||= ::Logger::UNKNOWN
+          configured_progname = respond_to?(:progname) ? self.progname : nil
+          captured = message.nil? && block.nil? ? (progname || configured_progname) : message
+          wrapped = block && proc { captured = block.call }
+          result = super(severity, message, progname, &wrapped)
+          sink = instance_variable_get(SINK_IVAR)
+          if sink && severity >= level
+            sink.level = level
+            sink.add(severity, captured)
+          end
+          result
+        end
+      end
+      private_constant :LoggerTap
+
+      module BroadcastOrigin
+        def dispatch(...)
+          previous = Thread.current[ORIGIN_KEY]
+          origin = ApplicationLogCapture.application_caller?(instance_variable_get(ROOT_IVAR))
+          Thread.current[ORIGIN_KEY] = origin
+          super
+        ensure
+          Thread.current[ORIGIN_KEY] = previous
+        end
+        private :dispatch
+      end
+      private_constant :BroadcastOrigin
+
+      module_function
+
+      def install(logger, runtime, application_root: nil)
+        return logger unless runtime.configuration.capture_rails_logs?
+        return logger if application_root.nil?
+        return logger unless logger.respond_to?(:add) || logger.respond_to?(:broadcast_to)
+        return logger unless logger.instance_variable_get(SINK_IVAR).nil?
+
+        level = logger.respond_to?(:level) ? logger.level : ::Logger::DEBUG
+        root = File.expand_path(application_root.to_s)
+        sink = Sink.new(runtime, root, level)
+        if logger.respond_to?(:broadcast_to)
+          logger.instance_variable_set(ROOT_IVAR, root)
+          logger.singleton_class.prepend(BroadcastOrigin)
+          logger.broadcast_to(sink)
+        else
+          logger.singleton_class.prepend(LoggerTap)
+        end
+        logger.instance_variable_set(SINK_IVAR, sink)
+        logger
+      rescue StandardError => error
+        runtime.report_error("application_log_installation", error)
+        logger
+      end
+
+      def capture(runtime, application_root, severity, message)
+        return if LogBrew::Trace.current.nil? || Thread.current[GUARD_KEY]
+        origin = Thread.current[ORIGIN_KEY]
+        origin = application_caller?(application_root) if origin.nil?
+        return unless origin
+
+        Thread.current[GUARD_KEY] = true
+        begin
+          client = runtime.client
+          return if client.nil?
+
+          text = message.is_a?(String) ? message : message.inspect
+          truncated = text.length > MAX_MESSAGE_CHARACTERS
+          metadata = runtime.metadata.merge(
+            "source" => "rails.logger",
+            "rubySeverity" => ::Logger::SEV_LABEL[severity.to_i] || "ANY",
+            "messageState" => truncated ? "truncated" : "captured"
+          )
+          client.log(
+            "ruby_rails_log_#{SecureRandom.hex(8)}",
+            Time.now.utc.iso8601(6),
+            message: text[0, MAX_MESSAGE_CHARACTERS],
+            level: LEVELS.fetch(severity.to_i, severity.to_i >= ::Logger::FATAL ? "critical" : "info"),
+            logger: "rails",
+            metadata: metadata
+          )
+        rescue StandardError => error
+          runtime.report_error("application_log_capture", error)
+        ensure
+          Thread.current[GUARD_KEY] = false
+        end
+      end
+
+      def application_caller?(application_root)
+        location = caller_locations(2, 24).find do |caller|
+          path = caller.absolute_path || caller.path
+          path && !path.start_with?(LIBRARY_ROOT) && path != LOGGER_PATH && !path.match?(LOGGER_WRAPPER_PATH)
+        end
+        return false if location.nil?
+
+        path = File.expand_path(location.absolute_path || location.path)
+        return false if GEM_ROOTS.any? { |root| path.start_with?(root) }
+
+        path == application_root || path.start_with?("#{application_root}#{File::SEPARATOR}")
+      rescue StandardError
+        false
+      end
+    end
+    private_constant :ApplicationLogCapture
+
     # Adds bounded child spans to Net::HTTP calls made inside an active Rails trace.
     module OutboundHttp
       module Request

data/lib/logbrew/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logbrew-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.12
 platform: ruby
 authors:
 - LogBrew