debugbundle 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b248dcbd96eccb5c6feb9720d0d68d91377469fc2a69e722f5ee665ac6b963b9
-  data.tar.gz: dd58681087f077b40b9a1d9efd6608f0f8ef9680bf1ca08cca3a382bd07811a1
+  metadata.gz: cae31875b7ffe9d2005b62f2107fb4810061ec4362e7bf48c4dd521e43d415f6
+  data.tar.gz: 2e005a0112e3197aa9b19fed791b71cea7dbf1eefcfc6edebc5a2ce7c764f3d0
 SHA512:
-  metadata.gz: e2c64054d0bee13e76b6e231102e9d8b13cd0806c03a82c7ba09b24e6baf8195ce2163022d7b7855041fd8939fb889dc0f3559f03188d340db793b7f320361d5
-  data.tar.gz: 02d6185279a906a1d3ce16bca8a6bc14359eecee788f89f5e8cd5c2c5844a2390e08e403ed9e750362fdf89c9152ca246930f469622898f7b97bdcfc72723094
+  metadata.gz: e2f99cad665ebbcd10ea0965ed97f16c1930567344848ead03aa2ff9d1ac297bf9260ba2915a72454d6843e2805e41ebc648525ab0250077c29ea3f8897a291a
+  data.tar.gz: 25a171fc0e6cd96c74a8cc7a85fde1dbfe52837d4c46cef69926e2b4c736df49912ffce294613b3c7738d4f6f7b8cdc2f4121f6898a1563c4e7056f237d52a55

data/Makefile

@@ -15,6 +15,12 @@ BUNDLE_ENV = BUNDLE_GEMFILE="$(BUNDLE_GEMFILE)"
 .PHONY: bundle-install test lint build shell compat-rack compat-rails compat-sidekiq compat
 .PHONY: smoke
 .PHONY: smoke-published
+.PHONY: test-focused check-docker
+check-docker:
+	docker run --rm -v "$(CURDIR):$(WORKDIR)" -w "$(WORKDIR)" $(RUBY_IMAGE) sh -lc 'BUNDLE_PATH=vendor/bundle bundle exec rubocop && BUNDLE_PATH=vendor/bundle bundle exec rspec && gem build debugbundle.gemspec'
+
+test-focused:
+	docker run --rm -v "$(CURDIR):$(WORKDIR)" -w "$(WORKDIR)" $(RUBY_IMAGE) sh -lc 'BUNDLE_PATH=vendor/bundle SIMPLECOV_MINIMUM_COVERAGE=0 bundle exec rspec $(TEST_FILES)'
 
 bundle-install:
 	$(DOCKER_RUN) sh -lc "$(BUNDLE_ENV) bundle config set path vendor/bundle && $(BUNDLE_ENV) bundle install"

data/README.md

@@ -4,6 +4,10 @@ Ruby SDK for DebugBundle.
 
 Use this gem to capture Ruby backend exceptions, request metadata, structured logs, runtime context, probe data, and browser relay traffic. It supports a singleton facade plus instance clients for Rack, Rails, Sidekiq, and explicit Ruby instrumentation.
 
+## Automatic capture and application filtering
+
+`capture_logger(logger)` respects the logger level, Rails silence and disabled output. Lazy message blocks are evaluated by the native logger: zero times when suppressed and once when accepted. Native return values and application block exceptions are preserved. DebugBundle applies its own configured minimum capture level after the logger accepts a message.
+
 ## Installation
 
 ```ruby
@@ -314,7 +318,7 @@ This repository also ships a clean-install app-driven smoke harness that validat
 
 ```sh
 make smoke
-make smoke-published VERSION=1.4.0
+make smoke-published VERSION=1.4.1
 ```
 
 `make smoke` builds the gem, installs it into a fresh RubyGems home, drives a Rack request plus a browser relay batch through the public SDK surface, validates event envelope shape, and confirms the mock ingestion endpoint receives the expected service, environment, SDK metadata, and correlation fields.

data/lib/debugbundle/logging.rb

@@ -16,24 +16,23 @@ module DebugBundle
 
     def self.install_stdlib_logger(logger, client:)
       interceptor = Module.new do
-        define_method(:add) do |severity, message = nil, progname = nil, &block|
-          was_capturing = Thread.current[RECURSION_GUARD_KEY]
-          unless was_capturing
-            Thread.current[RECURSION_GUARD_KEY] = true
-            resolved_message = message
-            resolved_message = block.call if resolved_message.nil? && block
-            resolved_message = progname if resolved_message.nil?
+        %i[add log].each do |method_name|
+          define_method(method_name) do |severity, message = nil, progname = nil, &block|
+            normalized_severity = severity || ::Logger::UNKNOWN
+            # Match Logger's early return, including Rails' thread-local level.
+            disabled = normalized_severity < level || (is_a?(::Logger) && instance_variable_get(:@logdev).nil?)
+            next super(severity, message, progname, &block) if disabled || Thread.current[RECURSION_GUARD_KEY]
 
-            client.capture_log(
-              resolved_message.to_s,
-              level: LOGGER_LEVEL_NAMES.fetch(severity || ::Logger::UNKNOWN, :warning),
-              context: { logger_name: logger.progname }
-            )
+            resolved_message = message
+            resolved_message = progname.nil? ? self.progname : progname if message.nil?
+            result = if message.nil? && block
+                       super(severity, message, progname) { resolved_message = block.call }
+                     else
+                       super(severity, message, progname)
+                     end
+            DebugBundle::Logging.capture_stdlib(client, resolved_message, normalized_severity, self.progname)
+            result
           end
-
-          super(severity, message, progname, &block)
-        ensure
-          Thread.current[RECURSION_GUARD_KEY] = was_capturing
         end
       end
 
@@ -41,6 +40,21 @@ module DebugBundle
       interceptor
     end
 
+    def self.capture_stdlib(client, message, severity, progname)
+      was_capturing = Thread.current[RECURSION_GUARD_KEY]
+      Thread.current[RECURSION_GUARD_KEY] = true
+      client.capture_log(
+        message.to_s,
+        level: LOGGER_LEVEL_NAMES.fetch(severity, :warning),
+        context: { logger_name: progname }
+      )
+    rescue StandardError
+      # SDK failures must not change the result of the application's logger.
+      nil
+    ensure
+      Thread.current[RECURSION_GUARD_KEY] = was_capturing
+    end
+
     def self.install_semantic_logger(client:)
       return nil unless defined?(::SemanticLogger)
       return nil unless ::SemanticLogger.respond_to?(:add_appender)

data/lib/debugbundle/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DebugBundle
-  VERSION = '1.4.0'
+  VERSION = '1.4.1'
 end

data/spec/logger_integration_spec.rb

@@ -4,6 +4,90 @@ require 'spec_helper'
 require 'stringio'
 
 RSpec.describe 'stdlib logger integration' do
+  def instrument_logger(logger, &capture)
+    client = Object.new
+    client.define_singleton_method(:capture_log, &capture)
+    DebugBundle::Logging.install_stdlib_logger(logger, client: client)
+  end
+
+  it 'respects the current logger level without evaluating suppressed blocks' do
+    output = StringIO.new
+    logger = Logger.new(output, level: Logger::ERROR)
+    captured = []
+    instrument_logger(logger) { |message, **_options| captured << message }
+    evaluations = 0
+    result = logger.warn do
+      evaluations += 1
+      'suppressed'
+    end
+    expect(result).to be(true)
+    expect(captured).to be_empty
+    expect(evaluations).to eq(0)
+    logger.level = Logger::WARN
+    logger.warn do
+      evaluations += 1
+      'accepted'
+    end
+    expect(evaluations).to eq(1)
+    expect(captured).to eq(['accepted'])
+    expect(output.string).to include('accepted')
+    expect(output.string).not_to include('suppressed')
+  end
+
+  it 'preserves logger message and progname semantics and evaluates accepted blocks once' do
+    output = StringIO.new
+    logger = Logger.new(output, progname: 'default-name')
+    captured = []
+    instrument_logger(logger) { |message, **_options| captured << message }
+    logger.add(Logger::WARN)
+    logger.add(Logger::WARN, nil, 'message-as-progname')
+    logger.add(nil, 'unknown-severity')
+    evaluations = 0
+    logger.warn('explicit-name') do
+      evaluations += 1
+      "block-#{evaluations}"
+    end
+    expect(captured).to eq(%w[default-name message-as-progname unknown-severity block-1])
+    expect(evaluations).to eq(1)
+    expect(output.string).to include('explicit-name: block-1')
+  end
+
+  it 'does not evaluate blocks or capture when the logger has no output device' do
+    logger = Logger.new(nil)
+    instrument_logger(logger) { raise 'should not capture' }
+    expect(logger.warn { raise 'should not evaluate' }).to be(true)
+  end
+
+  it 'captures the log alias and preserves false messages and Rails silence' do
+    require 'active_support'
+    require 'active_support/logger'
+    output = StringIO.new
+    logger = ActiveSupport::Logger.new(output)
+    captured = []
+    instrument_logger(logger) { |message, **_options| captured << message }
+    logger.silence(Logger::ERROR) { logger.warn { raise 'suppressed block' } }
+    logger.log(Logger::WARN, false)
+    expect(captured).to eq(['false'])
+    expect(output.string).to include('false')
+  end
+
+  it 'isolates capture failures and recursion while preserving application logging failures' do
+    output = StringIO.new
+    logger = Logger.new(output)
+    calls = 0
+    instrument_logger(logger) do |_message, **_options|
+      calls += 1
+      logger.warn('nested')
+      raise 'capture failed'
+    end
+    expect { logger.warn('outer') }.not_to raise_error
+    expect(calls).to eq(1)
+    expect(output.string).to include('outer', 'nested')
+    expect { logger.warn { raise 'application failure' } }.to raise_error('application failure')
+    expect { logger.warn('after failure') }.not_to raise_error
+    expect(calls).to eq(2)
+  end
+
   it 'captures log events without changing logger output' do
     transport_events = []
     transport = Class.new do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: debugbundle
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - DebugBundle
 bindir: exe
 cert_chain: []
-date: 2026-09-12 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64