debugbundle 1.4.0 → 1.5.0

data/spec/before_send_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe DebugBundle::BeforeSend do
-  let(:base_event) do
-    {
-      'schema_version' => '2026-03-01',
-      'event_id' => '11111111-1111-4111-8111-111111111111',
-      'event_type' => 'log_event',
-      'occurred_at' => '2026-07-27T08:00:00Z',
-      'sdk_name' => '@debugbundle/sdk-ruby',
-      'sdk_version' => '1.3.0',
-      'service' => { 'name' => 'ruby-test', 'environment' => 'test' },
-      'payload' => { 'level' => 'error', 'message' => 'failure', 'attributes' => {} }
-    }
-  end
-
-  it 'validates every closed canonical payload variant' do
-    payloads = {
-      'backend_exception' => {
-        'name' => 'RuntimeError', 'message' => 'failure', 'stack' => 'stack', 'handled' => true,
-        'request' => {}, 'response' => {}, 'runtime' => {}, 'probe_data' => {}
-      },
-      'request_event' => {
-        'method' => 'GET', 'path' => '/', 'query' => {}, 'headers' => {},
-        'response_status' => 503, 'duration_ms' => 10, 'response_headers' => {}
-      },
-      'frontend_breadcrumb' => { 'breadcrumb_type' => 'navigation', 'data' => {} },
-      'frontend_exception' => {
-        'name' => 'Error', 'message' => 'failure', 'stack' => 'stack',
-        'breadcrumbs' => [], 'probe_data' => {}
-      },
-      'deploy_metadata' => {
-        'commit_sha' => 'abc', 'version' => '1', 'branch' => 'main',
-        'environment' => 'test', 'deployed_at' => '2026-07-27T08:00:00Z'
-      },
-      'error_suppressed' => {
-        'fingerprint' => 'fp', 'suppressed_count' => 2, 'window_seconds' => 60,
-        'first_seen' => '2026-07-27T08:00:00Z', 'last_seen' => '2026-07-27T08:01:00Z'
-      },
-      'probe_event' => {
-        'label' => 'cart.total', 'data' => { 'value' => 2 },
-        'activation_id' => nil, 'probe_label_pattern' => 'cart.*'
-      }
-    }
-
-    payloads.each do |event_type, payload|
-      event = base_event.merge('event_type' => event_type, 'payload' => payload)
-      expect(described_class.valid?(event)).to be_truthy, event_type
-    end
-  end
-
-  it 'rejects malformed roots, timestamps, payload fields, and typed values' do
-    expect(described_class.valid?([])).to be(false)
-    expect(described_class.valid?(base_event.merge('unexpected' => true))).to be(false)
-    expect(described_class.valid?(base_event.merge('event_id' => 'not-a-uuid'))).to be(false)
-    expect(described_class.valid?(base_event.merge('occurred_at' => 'not-a-time'))).to be(false)
-    expect(
-      described_class.valid?(
-        base_event.merge('payload' => base_event['payload'].merge('unexpected' => true))
-      )
-    ).to be(false)
-    expect(described_class.valid?(base_event.merge('event_type' => 'unknown'))).to be_falsey
-  end
-
-  it 'covers strict scalar helpers used by request, suppression, and probe validation' do
-    expect(described_class.non_negative_number?(Float::INFINITY)).to be(false)
-    expect(described_class.non_negative_integer?(-1)).to be(false)
-    expect(described_class.positive_integer?(0)).to be(false)
-    expect(described_class.timestamp?('invalid')).to be(false)
-    expect(described_class.nullable_uuid?('invalid')).to be(false)
-  end
-end

data/spec/client_spec.rb

@@ -1,432 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'json'
-require 'tmpdir'
-
-RSpec.describe DebugBundle::Client do
-  let(:transport_events) { [] }
-  let(:transport) do
-    Class.new do
-      define_method(:initialize) do |transport_events|
-        @transport_events = transport_events
-      end
-
-      define_method(:call) do |request|
-        @transport_events << request
-        DebugBundle::Transport::Result.new(status_code: 202)
-      end
-    end.new(transport_events)
-  end
-
-  it 'buffers and flushes canonical events' do
-    client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      service: 'checkout-api',
-      environment: 'production',
-      transport: transport
-    )
-
-    client.set_context(:account_id, 'acct_123')
-    client.capture_log('payment retry failed', level: :error, context: { trace_id: 'trace-1' })
-
-    expect(client.buffered_event_count).to eq(1)
-    expect(client.flush).to be(true)
-    expect(client.last_event_at).not_to be_nil
-
-    payload = transport_events.fetch(0)
-    event = payload.fetch(:events).fetch(0)
-
-    expect(event.fetch('event_type')).to eq('log_event')
-    expect(event.fetch('schema_version')).to eq('2026-03-01')
-    expect(event.fetch('sdk_name')).to eq('@debugbundle/sdk-ruby')
-    expect(event.fetch('service')).to include('name' => 'checkout-api', 'environment' => 'production')
-    expect(event.fetch('correlation')).to include('trace_id' => 'trace-1')
-    expect(event.fetch('payload')).to include('level' => 'error', 'message' => 'payment retry failed')
-  end
-
-  it 'captures explicit exception blocks and re-raises' do
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: transport)
-
-    expect do
-      client.with_exception_capture(context: { request_id: 'req-1' }) do
-        raise ArgumentError, 'invalid checkout'
-      end
-    end.to raise_error(ArgumentError, 'invalid checkout')
-
-    client.flush
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-    expect(event.fetch('event_type')).to eq('backend_exception')
-    expect(event.fetch('payload')).to include('handled' => false)
-    expect(event.fetch('correlation')).to include('request_id' => 'req-1')
-  end
-
-  it 'registers at-exit capture once and flushes shutdown exceptions' do
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: transport)
-    registered_callback = nil
-
-    allow(client).to receive(:at_exit) do |&block|
-      registered_callback = block
-    end
-
-    expect(client.capture_exceptions).to be(true)
-    expect(client.capture_at_exit).to be(false)
-    expect(registered_callback).not_to be_nil
-
-    begin
-      raise 'shutdown boom'
-    rescue RuntimeError
-      registered_callback.call
-    end
-
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-    expect(event.fetch('event_type')).to eq('backend_exception')
-    expect(event.fetch('payload')).to include('handled' => false, 'message' => 'shutdown boom')
-  end
-
-  it 'captures unhandled thread exceptions after hooks are armed' do
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: transport)
-
-    allow(client).to receive(:at_exit)
-
-    expect(client.capture_exceptions).to be(true)
-
-    thread = Thread.new do
-      raise 'thread boom'
-    end
-
-    expect { thread.value }.to raise_error(RuntimeError, 'thread boom')
-
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-    expect(event.fetch('event_type')).to eq('backend_exception')
-    expect(event.fetch('payload')).to include('handled' => false, 'message' => 'thread boom')
-  end
-
-  it 'suppresses duplicate exceptions and emits an aggregate' do
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: transport)
-    error = RuntimeError.new('boom')
-    error.set_backtrace(['app/models/checkout.rb:10'])
-
-    5.times { client.capture_exception(error) }
-
-    expect(client.buffered_event_count).to eq(3)
-    client.flush
-
-    flushed_events = transport_events.fetch(0).fetch(:events)
-    expect(flushed_events.count { |event| event.fetch('event_type') == 'backend_exception' }).to eq(3)
-    expect(flushed_events.count { |event| event.fetch('event_type') == 'error_suppressed' }).to eq(1)
-  end
-
-  it 'wraps list, scalar, and nil probe data before exception attachment' do
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: transport)
-    client.probe('list', %w[first second])
-    client.probe('scalar', 42)
-    client.probe('nil', nil)
-    client.capture_exception(RuntimeError.new('boom'))
-
-    client.flush
-
-    exception = transport_events.fetch(0).fetch(:events).find do |event|
-      event.fetch('event_type') == 'backend_exception'
-    end
-    items = exception.fetch('payload').fetch('probe_data').fetch('items')
-    expect(items.map { |item| item.fetch('data') }).to eq(
-      [
-        { 'value' => %w[first second] },
-        { 'value' => 42 },
-        { 'value' => nil }
-      ]
-    )
-  end
-
-  it 'swallows probe callback failures' do
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: transport)
-
-    expect { client.probe('unsafe') { raise 'callback failed' } }.not_to raise_error
-  end
-
-  it 'runs before_send after redaction and mutates before queueing' do
-    observed_passwords = []
-    client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: transport,
-      before_send: lambda do |event|
-        observed_passwords << event.fetch('context').fetch('password')
-        event.fetch('payload')['message'] = 'mutated'
-        event
-      end
-    )
-    client.capture_message('original', level: :error, context: { password: 'secret' })
-
-    client.flush
-
-    expect(observed_passwords).to eq(['[REDACTED]'])
-    expect(transport_events.fetch(0).fetch(:events).fetch(0).dig('payload', 'message')).to eq('mutated')
-  end
-
-  it 'handles before_send drop, invalid return, failure, and sampling safely' do
-    calls = 0
-    dropping_client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: transport,
-      before_send: lambda do |_event|
-        calls += 1
-        nil
-      end
-    )
-    dropping_client.capture_message('drop', level: :error)
-    dropping_client.flush
-    expect(calls).to eq(1)
-    expect(transport_events).to be_empty
-
-    invalid_client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: transport,
-      before_send: ->(_event) { { 'invalid' => true } }
-    )
-    invalid_client.capture_message('preserve invalid', level: :error)
-    invalid_client.flush
-
-    failing_client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: transport,
-      before_send: ->(_event) { raise 'hook failed' }
-    )
-    failing_client.capture_message('preserve failure', level: :error)
-    failing_client.flush
-
-    expect(transport_events.map { |request| request.fetch(:events).fetch(0).dig('payload', 'message') }).to eq(
-      ['preserve invalid', 'preserve failure']
-    )
-
-    sampled_calls = 0
-    sampled_client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: transport,
-      sample_rate: 0,
-      before_send: lambda do |event|
-        sampled_calls += 1
-        event
-      end
-    )
-    sampled_client.capture_message('sampled out', level: :error)
-    sampled_client.flush
-    expect(sampled_calls).to eq(1)
-    expect(transport_events.length).to eq(2)
-  end
-
-  it 'backs off after 429 responses without dropping buffered events' do
-    retry_transport = Class.new do
-      def initialize
-        @calls = 0
-      end
-
-      def call(_request)
-        @calls += 1
-        return DebugBundle::Transport::Result.new(status_code: 429, retry_after_seconds: 1) if @calls == 1
-
-        DebugBundle::Transport::Result.new(status_code: 202)
-      end
-    end.new
-
-    current_time = Time.utc(2026, 5, 23, 12, 0, 0)
-    time_provider = -> { current_time }
-
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: retry_transport,
-                                 time_provider: time_provider)
-    client.capture_log('worker started', level: :warning)
-
-    expect(client.flush).to be(false)
-    expect(client.buffered_event_count).to eq(1)
-    expect(client.status).to eq(:degraded)
-
-    current_time += 2
-    expect(client.flush).to be(true)
-    expect(client.buffered_event_count).to eq(0)
-  end
-
-  it 'retries only the indexed retryable rejection from an acknowledgement' do
-    requests = []
-    responses = [
-      DebugBundle::Transport::Result.new(
-        status_code: 202,
-        body: {
-          'accepted' => 1,
-          'rejected' => 1,
-          'errors' => [{ 'index' => 1, 'reason' => 'rate_limited' }]
-        }
-      ),
-      DebugBundle::Transport::Result.new(
-        status_code: 202,
-        body: { 'accepted' => 1, 'rejected' => 0, 'errors' => [] }
-      )
-    ]
-    acknowledgement_transport = lambda do |request|
-      requests << request
-      responses.shift
-    end
-    current_time = Time.utc(2026, 5, 23, 12, 0, 0)
-    client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: acknowledgement_transport,
-      time_provider: -> { current_time }
-    )
-    client.capture_log('accepted', level: :warning)
-    client.capture_log('retry', level: :warning)
-
-    expect(client.flush).to be(false)
-    expect(client.buffered_event_count).to eq(1)
-    expect(client.last_event_at).not_to be_nil
-    expect(client.status).to eq(:degraded)
-
-    current_time += 2
-    expect(client.flush).to be(true)
-    expect(requests.fetch(1).fetch(:events).map { |event| event.dig('payload', 'message') }).to eq(['retry'])
-  end
-
-  it 'removes terminal rejections without reporting delivery success' do
-    calls = 0
-    acknowledgement_transport = lambda do |_request|
-      calls += 1
-      DebugBundle::Transport::Result.new(
-        status_code: 202,
-        body: {
-          'accepted' => 0,
-          'rejected' => 1,
-          'errors' => [{ 'index' => 0, 'reason' => 'capture_policy_rejected' }]
-        }
-      )
-    end
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: acknowledgement_transport)
-    client.capture_log('terminal', level: :warning)
-
-    expect(client.flush).to be(false)
-    expect(client.buffered_event_count).to eq(0)
-    expect(client.last_event_at).to be_nil
-    expect(client.status).to eq(:disconnected)
-    expect(client.flush).to be(true)
-    expect(calls).to eq(1)
-  end
-
-  it 'retains the full batch after an inconsistent acknowledgement' do
-    requests = []
-    responses = [
-      DebugBundle::Transport::Result.new(
-        status_code: 202,
-        body: { 'accepted' => 1, 'rejected' => 0, 'errors' => [] }
-      ),
-      DebugBundle::Transport::Result.new(
-        status_code: 202,
-        body: { 'accepted' => 2, 'rejected' => 0, 'errors' => [] }
-      )
-    ]
-    acknowledgement_transport = lambda do |request|
-      requests << request
-      responses.shift
-    end
-    current_time = Time.utc(2026, 5, 23, 12, 0, 0)
-    client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: acknowledgement_transport,
-      time_provider: -> { current_time }
-    )
-    client.capture_log('first', level: :warning)
-    client.capture_log('second', level: :warning)
-
-    expect(client.flush).to be(false)
-    expect(client.buffered_event_count).to eq(2)
-    expect(client.last_event_at).to be_nil
-    expect(client.status).to eq(:degraded)
-
-    current_time += 2
-    expect(client.flush).to be(true)
-    expect(requests.fetch(1).fetch(:events).length).to eq(2)
-  end
-
-  it 'defaults development captures to secure local event files' do
-    Dir.mktmpdir do |directory|
-      client = described_class.new(project_token: 'dbundle_proj_test', local_events_dir: directory)
-
-      client.capture_log('local event', level: :error)
-      expect(client.flush).to be(true)
-
-      file_name = Dir.children(directory).find { |entry| entry.end_with?('.events.json') }
-      event = JSON.parse(File.read(File.join(directory, file_name))).fetch(0)
-
-      expect(event.fetch('event_type')).to eq('log_event')
-      expect(event.fetch('payload')).to include('message' => 'local event')
-    end
-  end
-
-  it 'does not raise for invalid project mode configuration' do
-    expect do
-      described_class.new(project_token: 'dbundle_proj_test', project_mode: :surprising, transport: transport)
-    end.not_to raise_error
-  end
-
-  it 'applies sample rate before buffering events' do
-    client = described_class.new(
-      project_token: 'dbundle_proj_test',
-      transport: transport,
-      sample_rate: 0.25,
-      random_provider: -> { 0.9 }
-    )
-
-    client.capture_log('sampled out', level: :error)
-
-    expect(client.buffered_event_count).to eq(0)
-  end
-
-  it 'does not include local OS account names in runtime facts' do
-    client = described_class.new(project_token: 'dbundle_proj_test', transport: transport)
-
-    client.capture_exception(RuntimeError.new('privacy check'))
-    client.flush
-
-    runtime = transport_events.fetch(0).fetch(:events).fetch(0).fetch('payload').fetch('runtime')
-    expect(runtime).not_to have_key('user')
-  end
-
-  it 'builds a default remote config fetcher for connected remote environments' do
-    fetcher_instances = []
-    fetcher_class = Class.new do
-      define_method(:initialize) do |endpoint, project_token:, sdk_name:, sdk_version:|
-        fetcher_instances << {
-          endpoint: endpoint,
-          project_token: project_token,
-          sdk_name: sdk_name,
-          sdk_version: sdk_version
-        }
-      end
-
-      define_method(:call) do |_etag|
-        {
-          status_code: 200,
-          etag: 'cfg-default',
-          body: {
-            capture_policy: {
-              preset: 'minimal',
-              capture_logs: 'error',
-              capture_request_events: 'failures_only',
-              capture_breadcrumbs: 'local_only',
-              capture_probe_events: 'buffer_only',
-              immediate_client_error_statuses: []
-            }
-          }
-        }
-      end
-    end
-
-    stub_const('DebugBundle::Transport::HttpConfigFetcher', fetcher_class)
-
-    client = described_class.new(project_token: 'dbundle_proj_test', environment: 'production')
-    client.capture_log('warning dropped by default fetched policy', level: :warning)
-
-    expect(fetcher_instances.fetch(0)).to include(
-      endpoint: DebugBundle::Config::DEFAULT_ENDPOINT,
-      project_token: 'dbundle_proj_test',
-      sdk_name: '@debugbundle/sdk-ruby'
-    )
-    expect(client.buffered_event_count).to eq(0)
-  end
-end

data/spec/debugbundle_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe DebugBundle do
-  before do
-    described_class.client = DebugBundle::Client.new
-  end
-
-  it 'exposes the universal singleton interface' do
-    client = described_class.init(project_token: 'dbundle_proj_test', service: 'checkout-api')
-
-    expect(client).to be_a(DebugBundle::Client)
-    expect(described_class).to respond_to(:init)
-    expect(described_class).to respond_to(:capture_exception)
-    expect(described_class).to respond_to(:capture_error)
-    expect(described_class).to respond_to(:capture_log)
-    expect(described_class).to respond_to(:capture_request)
-    expect(described_class).to respond_to(:capture_message)
-    expect(described_class).to respond_to(:set_context)
-    expect(described_class).to respond_to(:probe)
-    expect(described_class).to respond_to(:flush)
-    expect(described_class).to respond_to(:status)
-    expect(described_class).to respond_to(:last_event_at)
-  end
-
-  it 'arms exception capture when initialized' do
-    client = instance_double(DebugBundle::Client)
-    allow(DebugBundle::Client).to receive(:new).and_return(client)
-    allow(client).to receive(:capture_exceptions).and_return(true)
-
-    expect(client).to receive(:capture_exceptions)
-    expect(described_class.init(project_token: 'dbundle_proj_test')).to be(client)
-  end
-
-  it 'reports a degraded status without a configured project token' do
-    described_class.client = DebugBundle::Client.new
-
-    expect(described_class.status).to eq(:degraded)
-  end
-
-  it 'records the last event timestamp on flush' do
-    transport = Class.new do
-      def call(_request)
-        DebugBundle::Transport::Result.new(status_code: 202)
-      end
-    end.new
-
-    described_class.client = DebugBundle::Client.new(project_token: 'dbundle_proj_test', transport: transport)
-    described_class.capture_log('worker started', level: :warning)
-
-    expect { described_class.flush }.to change(described_class, :last_event_at).from(nil)
-  end
-end

data/spec/file_transport_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'json'
-require 'tmpdir'
-
-RSpec.describe DebugBundle::Transport::FileTransport do
-  it 'derives the remote SDK config endpoint from the events endpoint' do
-    expect(DebugBundle::Transport.sdk_config_endpoint('https://api.debugbundle.com/v1/events')).to eq(
-      'https://api.debugbundle.com/v1/sdk/config'
-    )
-    expect(DebugBundle::Transport.sdk_config_endpoint('https://api.debugbundle.com/events')).to eq(
-      'https://api.debugbundle.com/sdk/config'
-    )
-    expect(DebugBundle::Transport.sdk_config_endpoint('https://api.debugbundle.com/v1/sdk/config')).to eq(
-      'https://api.debugbundle.com/v1/sdk/config'
-    )
-  end
-
-  it 'writes local event batches with secure permissions' do
-    Dir.mktmpdir do |directory|
-      transport = described_class.new(directory)
-      result = transport.call(
-        project_token: 'dbundle_proj_test',
-        service_name: 'checkout-api',
-        events: [{ 'event_type' => 'log_event', 'payload' => { 'message' => 'ok' } }]
-      )
-
-      expect(result.status_code).to eq(202)
-
-      file_path = Dir.children(directory).find { |name| name.end_with?('.events.json') }
-      expect(file_path).not_to be_nil
-
-      full_path = File.join(directory, file_path)
-      parsed = JSON.parse(File.read(full_path))
-      expect(parsed.length).to eq(1)
-      expect(parsed.fetch(0)).to include('event_type' => 'log_event')
-      expect(File.stat(full_path).mode & 0o777).to eq(0o600)
-      expect(File.stat(directory).mode & 0o777).to eq(0o700)
-    end
-  end
-
-  it 'rejects traversal-style local event directories without raising into the caller' do
-    transport = described_class.new('../debugbundle-events')
-
-    result = transport.call(
-      project_token: 'dbundle_proj_test',
-      service_name: 'checkout-api',
-      events: [{ 'event_type' => 'log_event', 'payload' => { 'message' => 'ok' } }]
-    )
-
-    expect(result.status_code).to eq(500)
-  end
-end