debugbundle 1.4.0 → 1.5.0

data/spec/fixtures/event-envelope.schema.json

@@ -1,142 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://debugbundle.com/schemas/event-envelope-ruby-fixture.json",
-  "oneOf": [
-    {
-      "$ref": "#/$defs/request_event_envelope"
-    },
-    {
-      "$ref": "#/$defs/log_event_envelope"
-    },
-    {
-      "$ref": "#/$defs/frontend_exception_envelope"
-    }
-  ],
-  "$defs": {
-    "string_map": {
-      "type": "object",
-      "additionalProperties": true
-    },
-    "service": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["name", "environment"],
-      "properties": {
-        "name": { "type": "string", "minLength": 1 },
-        "runtime": { "type": ["string", "null"], "minLength": 1 },
-        "framework": { "type": ["string", "null"], "minLength": 1 },
-        "environment": { "type": "string", "minLength": 1 }
-      }
-    },
-    "correlation": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "request_id": { "type": ["string", "null"] },
-        "trace_id": { "type": ["string", "null"] },
-        "session_id": { "type": ["string", "null"] },
-        "user_id_hash": { "type": ["string", "null"] }
-      }
-    },
-    "envelope_base": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "schema_version",
-        "event_id",
-        "event_type",
-        "sdk_name",
-        "sdk_version",
-        "service",
-        "occurred_at",
-        "correlation",
-        "payload"
-      ],
-      "properties": {
-        "schema_version": { "type": "string", "minLength": 1 },
-        "event_id": { "type": "string", "format": "uuid" },
-        "event_type": { "type": "string", "minLength": 1 },
-        "project_token": { "type": "string", "minLength": 1 },
-        "project_id": { "type": ["string", "null"], "format": "uuid" },
-        "sdk_name": { "type": "string", "minLength": 1 },
-        "sdk_version": { "type": "string", "minLength": 1 },
-        "service": { "$ref": "#/$defs/service" },
-        "occurred_at": { "type": "string", "format": "date-time" },
-        "correlation": { "$ref": "#/$defs/correlation" },
-        "context": {
-          "type": "object",
-          "additionalProperties": true
-        },
-        "payload": {}
-      }
-    },
-    "request_event_envelope": {
-      "allOf": [
-        { "$ref": "#/$defs/envelope_base" },
-        {
-          "properties": {
-            "event_type": { "const": "request_event" },
-            "payload": {
-              "type": "object",
-              "additionalProperties": false,
-              "required": ["method", "path", "query", "headers", "response_status", "duration_ms"],
-              "properties": {
-                "method": { "type": "string", "minLength": 1 },
-                "path": { "type": "string", "minLength": 1 },
-                "query": { "$ref": "#/$defs/string_map" },
-                "headers": { "$ref": "#/$defs/string_map" },
-                "body": {},
-                "response_status": { "type": "integer", "minimum": 0 },
-                "duration_ms": { "type": "number", "minimum": 0 },
-                "route_template": { "type": ["string", "null"] },
-                "controller": { "type": ["string", "null"] },
-                "action": { "type": ["string", "null"] },
-                "response_headers": { "$ref": "#/$defs/string_map" },
-                "response_body": {}
-              }
-            }
-          }
-        }
-      ]
-    },
-    "log_event_envelope": {
-      "allOf": [
-        { "$ref": "#/$defs/envelope_base" },
-        {
-          "properties": {
-            "event_type": { "const": "log_event" },
-            "payload": {
-              "type": "object",
-              "additionalProperties": false,
-              "required": ["level", "message", "attributes"],
-              "properties": {
-                "level": { "type": "string", "minLength": 1 },
-                "message": { "type": "string", "minLength": 1 },
-                "attributes": { "$ref": "#/$defs/string_map" }
-              }
-            }
-          }
-        }
-      ]
-    },
-    "frontend_exception_envelope": {
-      "allOf": [
-        { "$ref": "#/$defs/envelope_base" },
-        {
-          "properties": {
-            "event_type": { "const": "frontend_exception" },
-            "sdk_name": { "const": "@debugbundle/sdk-browser" },
-            "payload": {
-              "type": "object",
-              "additionalProperties": true,
-              "required": ["message"],
-              "properties": {
-                "message": { "type": "string", "minLength": 1 }
-              }
-            }
-          }
-        }
-      ]
-    }
-  }
-}

data/spec/logger_integration_spec.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'stringio'
-
-RSpec.describe 'stdlib logger integration' do
-  it 'captures log events without changing logger output' do
-    transport_events = []
-    transport = 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)
-
-    output = StringIO.new
-    logger = Logger.new(output)
-    logger.progname = 'checkout'
-
-    client = DebugBundle::Client.new(project_token: 'dbundle_proj_test', transport: transport)
-    client.capture_logger(logger)
-    client.capture_logger(logger)
-
-    logger.warn('payment retry failed')
-    client.flush
-
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-
-    expect(output.string).to include('payment retry failed')
-    expect(event.fetch('event_type')).to eq('log_event')
-    expect(event.fetch('payload')).to include('message' => 'payment retry failed', 'level' => 'warning')
-    expect(event.fetch('payload').fetch('attributes')).to include('logger_name' => 'checkout')
-  end
-
-  it 'registers a semantic logger appender when SemanticLogger is available' do
-    transport_events = []
-    transport = 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)
-
-    semantic_logger = Module.new do
-      class << self
-        attr_reader :appenders
-
-        def add_appender(appender:)
-          @appenders ||= []
-          @appenders << appender
-        end
-      end
-    end
-
-    stub_const('SemanticLogger', semantic_logger)
-
-    log_entry = Struct.new(:message, :level, :name, :payload, :tags).new(
-      'semantic failure',
-      :error,
-      'semantic-checkout',
-      { order_id: 123 },
-      %w[payments critical]
-    )
-
-    client = DebugBundle::Client.new(project_token: 'dbundle_proj_test', transport: transport)
-    appender = client.capture_semantic_logger
-    appender.log(log_entry)
-    client.flush
-
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-
-    expect(SemanticLogger.appenders).to include(appender)
-    expect(event.fetch('payload')).to include('message' => 'semantic failure', 'level' => 'error')
-    expect(event.fetch('payload').fetch('attributes')).to include(
-      'logger_name' => 'semantic-checkout',
-      'payload' => { 'order_id' => 123 },
-      'tags' => %w[payments critical]
-    )
-  end
-
-  it 'guards semantic logger capture against recursive SDK logging' do
-    capture_count = 0
-    appender = nil
-    log_entry = Struct.new(:message, :level, :name, :payload, :tags).new(
-      'semantic recursion check',
-      :error,
-      'semantic-checkout',
-      {},
-      []
-    )
-    recursive_client = Class.new do
-      define_method(:initialize) do |on_capture|
-        @on_capture = on_capture
-      end
-
-      define_method(:capture_log) do |_message, level:, context:|
-        @on_capture.call(level, context)
-      end
-    end.new(lambda do |_level, _context|
-      capture_count += 1
-      appender.log(log_entry)
-    end)
-
-    appender = DebugBundle::Logging::SemanticLoggerAppender.new(client: recursive_client)
-
-    appender.log(log_entry)
-
-    expect(capture_count).to eq(1)
-  end
-end

data/spec/rack_integration_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'rack'
-require 'rack/mock'
-
-RSpec.describe 'Rack integration' 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 'captures request context in a real Rack builder stack' do
-    client = DebugBundle::Client.new(project_token: 'dbundle_proj_test', service: 'rack-checkout', transport: transport)
-    app = Rack::Builder.new do
-      use DebugBundle::Rack::Middleware, client: client
-      run ->(_env) { [503, { 'Content-Type' => 'text/plain' }, ['ok']] }
-    end.to_app
-
-    response = Rack::MockRequest.new(app).get(
-      '/checkout?cart_id=123',
-      'HTTP_X_REQUEST_ID' => 'req-rack',
-      'HTTP_X_DEBUGBUNDLE_TRACE_ID' => 'trace-rack'
-    )
-
-    client.flush
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-
-    expect(response.status).to eq(503)
-    expect(response.body).to eq('ok')
-    expect(event.fetch('event_type')).to eq('request_event')
-    expect(event.fetch('correlation')).to include('request_id' => 'req-rack', 'trace_id' => 'trace-rack')
-    expect(event.fetch('payload')).to include('path' => '/checkout', 'method' => 'GET', 'response_status' => 503)
-  end
-end

data/spec/rack_middleware_spec.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'base64'
-require 'json'
-require 'openssl'
-
-RSpec.describe DebugBundle::Rack::Middleware do
-  let(:transport_events) { [] }
-  let(:client) do
-    transport = 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)
-
-    config_fetcher = lambda do |_etag|
-      {
-        status_code: 200,
-        etag: 'rack-etag',
-        body: {
-          capture_policy: {
-            preset: 'balanced',
-            capture_logs: 'warning',
-            capture_request_events: 'all',
-            capture_breadcrumbs: 'exception_only',
-            capture_probe_events: 'buffer_only',
-            immediate_client_error_statuses: []
-          }
-        }
-      }
-    end
-
-    DebugBundle::Client.new(
-      project_token: 'dbundle_proj_test',
-      service: 'checkout-api',
-      transport: transport,
-      config_fetcher: config_fetcher
-    )
-  end
-
-  it 'captures request metadata and preserves the response' do
-    app = lambda do |_env|
-      [201, { 'Content-Type' => 'application/json', 'Set-Cookie' => 'secret' }, ['ok']]
-    end
-
-    middleware = described_class.new(app, client: client)
-    status, headers, body = middleware.call(
-      'REQUEST_METHOD' => 'POST',
-      'PATH_INFO' => '/checkout',
-      'QUERY_STRING' => 'cart_id=123',
-      'HTTP_X_REQUEST_ID' => 'req-1',
-      'HTTP_X_DEBUGBUNDLE_TRACE_ID' => 'trace-1',
-      'HTTP_AUTHORIZATION' => 'Bearer secret',
-      'HTTP_USER_AGENT' => 'RSpec'
-    )
-
-    client.flush
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-
-    expect(status).to eq(201)
-    expect(headers).to include('Content-Type' => 'application/json')
-    expect(body).to eq(['ok'])
-    expect(event.fetch('event_type')).to eq('request_event')
-    expect(event.fetch('correlation')).to include('request_id' => 'req-1', 'trace_id' => 'trace-1')
-    expect(event.fetch('payload').fetch('headers')).to include('user-agent' => 'RSpec')
-    expect(event.fetch('payload').fetch('headers')).not_to have_key('authorization')
-    expect(event.fetch('payload').fetch('response_headers')).to include('content-type' => 'application/json')
-    expect(event.fetch('payload').fetch('response_headers')).not_to have_key('set-cookie')
-  end
-
-  it 'captures exceptions and re-raises them' do
-    app = lambda do |_env|
-      raise 'checkout failure'
-    end
-
-    middleware = described_class.new(app, client: client)
-
-    expect do
-      middleware.call(
-        'REQUEST_METHOD' => 'GET',
-        'PATH_INFO' => '/checkout',
-        'QUERY_STRING' => '',
-        'HTTP_X_REQUEST_ID' => 'req-2'
-      )
-    end.to raise_error(RuntimeError, 'checkout failure')
-
-    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-2')
-  end
-
-  it 'activates trigger-token probe shipping for a single request' do
-    trigger_key = 'trigger-secret'
-    expires_at = (Time.now.utc + 60).iso8601
-    payload_json = JSON.generate(
-      activation_id: 'probe-1',
-      label_pattern: 'checkout.*',
-      service: '*',
-      environment: '*',
-      trigger_expires_at: expires_at
-    )
-    payload_segment = Base64.urlsafe_encode64(payload_json, padding: false)
-    signature = OpenSSL::HMAC.digest('sha256', trigger_key, payload_segment)
-    token = "dbundle_probe_#{payload_segment}.#{Base64.urlsafe_encode64(signature, padding: false)}"
-
-    transport = 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)
-
-    config_fetcher = lambda do |_etag|
-      {
-        status_code: 200,
-        etag: 'rack-trigger-etag',
-        body: {
-          probes_enabled: true,
-          remote_probes_enabled: true,
-          trigger_token_key: trigger_key,
-          capture_policy: {
-            preset: 'balanced',
-            capture_logs: 'warning',
-            capture_request_events: 'all',
-            capture_breadcrumbs: 'exception_only',
-            capture_probe_events: 'buffer_only',
-            immediate_client_error_statuses: []
-          }
-        }
-      }
-    end
-
-    trigger_client = DebugBundle::Client.new(
-      project_token: 'dbundle_proj_test',
-      service: 'checkout-api',
-      transport: transport,
-      config_fetcher: config_fetcher
-    )
-
-    app = lambda do |_env|
-      trigger_client.probe('checkout.tax', { region: 'us-east-1' })
-      [200, { 'Content-Type' => 'application/json' }, ['ok']]
-    end
-
-    middleware = described_class.new(app, client: trigger_client)
-    middleware.call(
-      'REQUEST_METHOD' => 'GET',
-      'PATH_INFO' => '/checkout',
-      'QUERY_STRING' => '',
-      'HTTP_X_DEBUGBUNDLE_PROBE_TRIGGER' => token,
-      'HTTP_X_REQUEST_ID' => 'req-trigger'
-    )
-
-    trigger_client.flush
-    events = transport_events.fetch(0).fetch(:events)
-    probe_event = events.find { |entry| entry.fetch('event_type') == 'probe_event' }
-
-    expect(probe_event).not_to be_nil
-    expect(probe_event.fetch('payload')).to include(
-      'label' => 'checkout.tax',
-      'activation_id' => 'probe-1',
-      'probe_label_pattern' => 'checkout.*'
-    )
-  end
-
-  it 'captures Rails route, controller, and action metadata when present' do
-    app = lambda do |_env|
-      [422, { 'Content-Type' => 'application/json' }, ['invalid']]
-    end
-
-    middleware = described_class.new(app, client: client)
-    middleware.call(
-      'REQUEST_METHOD' => 'POST',
-      'PATH_INFO' => '/patients/123/checkouts',
-      'QUERY_STRING' => '',
-      'action_dispatch.request_id' => 'req-rails',
-      'action_dispatch.route_uri_pattern' => '/patients/:patient_id/checkouts',
-      'action_dispatch.request.parameters' => {
-        'controller' => 'checkouts',
-        'action' => 'create'
-      }
-    )
-
-    client.flush
-    event = transport_events.fetch(0).fetch(:events).fetch(0)
-    payload = event.fetch('payload')
-    context = event.fetch('context')
-
-    expect(payload).to include(
-      'route_template' => '/patients/:patient_id/checkouts'
-    )
-    expect(context).to include(
-      'controller' => 'checkouts',
-      'action' => 'create'
-    )
-  end
-end

data/spec/rails_railtie_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'json'
-require 'logger'
-require 'rack/test'
-require 'rails'
-require 'debugbundle/rails'
-
-RSpec.describe 'Rails Railtie integration' do
-  include Rack::Test::Methods
-
-  def app
-    @app ||= build_rails_app
-  end
-
-  after do
-    @app = nil
-    DebugBundle.client = nil
-    Rails.instance_variable_set(:@application, nil)
-  end
-
-  it 'mounts the configured relay route and forwards browser events' do
-    post '/relay/browser',
-         JSON.generate('batch' => [browser_event]),
-         {
-           'CONTENT_TYPE' => 'application/json',
-           'HTTP_HOST' => 'app.example.com',
-           'HTTP_ORIGIN' => 'https://app.example.com'
-         }
-
-    expect(last_response.status).to eq(202)
-    expect(last_response.headers.fetch('Content-Type')).to include('application/json')
-    expect(JSON.parse(last_response.body)).to include('accepted' => 1, 'rejected' => 0)
-    expect(@transport_events.fetch(0).fetch(:events).fetch(0).fetch('service')).to include(
-      'name' => 'rails-checkout',
-      'environment' => 'production'
-    )
-
-    post '/debugbundle/browser',
-         JSON.generate('batch' => [browser_event]),
-         {
-           'CONTENT_TYPE' => 'application/json',
-           'HTTP_HOST' => 'app.example.com',
-           'HTTP_ORIGIN' => 'https://app.example.com'
-         }
-
-    expect(last_response.status).to eq(404)
-  end
-
-  def build_rails_app
-    @transport_events = []
-    forward_transport = 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)
-
-    app_class = Class.new(Rails::Application) do
-      config.root = File.expand_path('..', __dir__)
-      config.eager_load = false
-      config.secret_key_base = 'test-secret'
-      config.logger = Logger.new(nil)
-    end
-
-    app_class.config.hosts << 'app.example.com' if app_class.config.respond_to?(:hosts)
-    app_class.config.debugbundle.project_token = 'dbundle_proj_test'
-    app_class.config.debugbundle.service = 'rails-checkout'
-    app_class.config.debugbundle.environment = 'production'
-    app_class.config.debugbundle.relay_durable_write = false
-    app_class.config.debugbundle.relay_allowed_origins = ['https://app.example.com']
-    app_class.config.debugbundle.relay_forward_transport = forward_transport
-    app_class.config.debugbundle.relay_path = '/relay/browser'
-    app_class.initialize!
-    app_class
-  end
-
-  def browser_event
-    {
-      'schema_version' => '2026-03-01',
-      'event_id' => 'evt-1',
-      'event_type' => 'frontend_exception',
-      'sdk_name' => '@debugbundle/sdk-browser',
-      'sdk_version' => '0.1.0',
-      'occurred_at' => Time.now.utc.iso8601,
-      'service' => { 'name' => 'browser-app', 'environment' => 'production' },
-      'correlation' => { 'trace_id' => 'trace-1' },
-      'payload' => { 'message' => 'boom' }
-    }
-  end
-end