debugbundle 1.4.1 → 2.0.0

data/lib/debugbundle/relay/handler.rb

@@ -182,7 +182,7 @@ module DebugBundle
         payload = candidate['payload']
         return nil unless service.is_a?(Hash) && payload.is_a?(Hash)
 
-        {
+        sanitized = {
           'schema_version' => candidate['schema_version'].to_s,
           'event_id' => candidate['event_id'].to_s,
           'event_type' => event_type,
@@ -197,6 +197,14 @@ module DebugBundle
           'payload' => payload,
           'project_token' => @project_token
         }
+        return nil unless TelemetryPrivacy.safe_event_identity?(sanitized)
+
+        fields = TelemetryPrivacy.protect({ 'service' => sanitized['service'], 'payload' => sanitized['payload'] })
+        return nil unless fields['service'].is_a?(Hash) && fields['payload'].is_a?(Hash)
+
+        sanitized.merge('service' => fields['service'], 'payload' => fields['payload'])
+      rescue StandardError
+        nil
       end
 
       def sanitize_correlation(value, event_type)

data/lib/debugbundle/safe_input.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module DebugBundle
+  # Built-in scalar extraction for capture paths that must not run application renderers.
+  module SafeInput
+    module_function
+
+    def key(value)
+      is_a = Object.instance_method(:is_a?)
+      return String.instance_method(:[]).bind_call(value, 0, 128) if is_a.bind_call(value, String)
+      return Symbol.instance_method(:to_s).bind_call(value)[0, 128] if is_a.bind_call(value, Symbol)
+
+      if is_a.bind_call(value, Integer) && Integer.instance_method(:bit_length).bind_call(value) <= 512
+        return Integer.instance_method(:to_s).bind_call(value)
+      end
+
+      nil
+    rescue StandardError
+      nil
+    end
+
+    def request_path(value)
+      return '/' unless Object.instance_method(:is_a?).bind_call(value, String)
+
+      raw = String.instance_method(:[]).bind_call(value, 0, 2_048)
+      begin
+        uri = URI.parse(raw)
+        return uri.path if uri.path && !uri.path.empty?
+      rescue URI::InvalidURIError
+        # Fall through to the bounded path-only fallback.
+      end
+      fallback = raw.split('?', 2).first.to_s.split('#', 2).first
+      fallback.start_with?('/') && !fallback.empty? ? fallback : '/'
+    rescue StandardError
+      '/'
+    end
+  end
+end

data/lib/debugbundle/suppression.rb

@@ -11,6 +11,7 @@ module DebugBundle
     LOOP_RESET_AFTER_SECONDS = 60.0
     LOOP_CHECKPOINT_SECONDS = 30.0
     MAX_NORMAL_EVENTS_PER_WINDOW = 3
+    MAX_TRACKED_FINGERPRINTS = 2_048
 
     State = Struct.new(
       :window_started_at,
@@ -29,14 +30,28 @@ module DebugBundle
     class Tracker
       def initialize
         @states = {}
+        @mutex = Mutex.new
+        @overflow_count = 0
+        @overflow_first_seen_at = nil
+        @overflow_last_seen_at = nil
       end
 
       def should_capture(key, now:)
-        state = (@states[key] ||= new_state(now))
+        locked = @mutex.try_lock
+        return true unless locked
+
+        fingerprint = Digest::SHA256.hexdigest(key)
+        state = @states.delete(fingerprint)
+        if state.nil? && @states.length >= MAX_TRACKED_FINGERPRINTS
+          _, evicted = @states.shift
+          record_overflow(evicted) if evicted.pending_suppressed_count.positive?
+        end
+        state ||= new_state(now)
+        @states[fingerprint] = state
 
         if state.suppression_mode && (now - state.last_seen_at) >= LOOP_RESET_AFTER_SECONDS
-          @states[key] = new_state(now)
-          state = @states[key]
+          @states[fingerprint] = new_state(now)
+          state = @states[fingerprint]
         end
 
         if (now - state.window_started_at) >= DUPLICATE_WINDOW_SECONDS
@@ -65,31 +80,58 @@ module DebugBundle
 
         mark_suppressed(state, now)
         false
+      ensure
+        @mutex.unlock if locked
       end
 
       def drain_aggregates(now:)
-        @states.each_with_object([]) do |(key, state), aggregates|
-          next if state.pending_suppressed_count.zero?
-          next if state.pending_first_seen_at.nil? || state.pending_last_seen_at.nil?
-          next if checkpoint_not_due?(state, now)
-
-          aggregates << {
-            'fingerprint' => Digest::SHA256.hexdigest(key),
-            'suppressed_count' => state.pending_suppressed_count,
-            'first_seen' => Time.at(state.pending_first_seen_at).utc.iso8601,
-            'last_seen' => Time.at(state.pending_last_seen_at).utc.iso8601,
-            'window_seconds' => DUPLICATE_WINDOW_SECONDS.to_i
-          }
-
-          state.pending_suppressed_count = 0
-          state.pending_first_seen_at = nil
-          state.pending_last_seen_at = nil
-          state.last_aggregate_emitted_at = now
+        @mutex.synchronize do
+          aggregates = @states.each_with_object([]) do |(fingerprint, state), results|
+            next if state.pending_suppressed_count.zero?
+            next if state.pending_first_seen_at.nil? || state.pending_last_seen_at.nil?
+            next if checkpoint_not_due?(state, now)
+
+            results << {
+              'fingerprint' => fingerprint,
+              'suppressed_count' => state.pending_suppressed_count,
+              'first_seen' => Time.at(state.pending_first_seen_at).utc.iso8601,
+              'last_seen' => Time.at(state.pending_last_seen_at).utc.iso8601,
+              'window_seconds' => DUPLICATE_WINDOW_SECONDS.to_i
+            }
+
+            state.pending_suppressed_count = 0
+            state.pending_first_seen_at = nil
+            state.pending_last_seen_at = nil
+            state.last_aggregate_emitted_at = now
+          end
+          append_overflow_aggregate(aggregates)
+          aggregates
         end
       end
 
       private
 
+      def record_overflow(state)
+        @overflow_first_seen_at ||= state.pending_first_seen_at
+        @overflow_count += state.pending_suppressed_count
+        @overflow_last_seen_at = state.pending_last_seen_at
+      end
+
+      def append_overflow_aggregate(aggregates)
+        return if @overflow_count.zero?
+
+        aggregates << {
+          'fingerprint' => Digest::SHA256.hexdigest('ruby:suppression-state-pressure'),
+          'suppressed_count' => @overflow_count,
+          'first_seen' => Time.at(@overflow_first_seen_at).utc.iso8601,
+          'last_seen' => Time.at(@overflow_last_seen_at).utc.iso8601,
+          'window_seconds' => DUPLICATE_WINDOW_SECONDS.to_i
+        }
+        @overflow_count = 0
+        @overflow_first_seen_at = nil
+        @overflow_last_seen_at = nil
+      end
+
       def new_state(now)
         State.new(
           window_started_at: now,

data/lib/debugbundle/telemetry_privacy.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'uri'
+
+module DebugBundle
+  # Mandatory bounded policy for application data; protocol-owned identifiers stay outside this projection.
+  module TelemetryPrivacy
+    REDACTED = '[REDACTED]'
+    MAX_BYTES = 262_144
+    FIELDS = %w[
+      password secret token api_key apikey access_token refresh_token private_key passwd
+      card_number credit_card cvv cvc pin expiry phone bearer session_id otp
+      verification_code authorization cookie ssn client_secret x_api_key set_cookie
+      proxy_authorization accessToken refreshToken privateKey clientSecret
+    ].freeze
+    ASSIGNMENT_VALUE_PATTERN = '(?:"[^"]*"|\'[^\']*\'|[^\s&,;]+)'
+    DEFAULT_ASSIGNMENT_PATTERN = Regexp.new(
+      "\\b(#{FIELDS.map { |field| Regexp.escape(field) }.join('|')})\\b([\"']?\\s*[:=]\\s*)#{ASSIGNMENT_VALUE_PATTERN}",
+      Regexp::IGNORECASE
+    )
+
+    module_function
+
+    def protect(value, additional_fields: [])
+      raise ArgumentError, 'unsafe_input' if additional_fields.length > 128
+      unless additional_fields.all? { |field| field.is_a?(String) && field.length.between?(1, 64) }
+        raise ArgumentError, 'unsafe_input'
+      end
+
+      work = { nodes: 0, bytes: 0, seen: {}.compare_by_identity,
+               fields: (FIELDS + additional_fields).map { |field| canonical(field) },
+               extra: additional_fields,
+               assignment_pattern: assignment_pattern(additional_fields) }
+      result = visit(value, work, 0, true)
+      raise ArgumentError, 'budget_exceeded' if JSON.generate(result).bytesize > MAX_BYTES
+
+      result
+    rescue JSON::GeneratorError, Encoding::InvalidByteSequenceError
+      raise ArgumentError, 'unsafe_input'
+    end
+
+    def safe_event_identity?(event, additional_fields: [])
+      correlation = event['correlation'] || {}
+      return false unless correlation.is_a?(Hash) && correlation.size <= 8
+
+      values = event.values_at('schema_version', 'sdk_name', 'sdk_version') + correlation.values
+      values.all? do |value|
+        value.nil? || (value.is_a?(String) && protect(value, additional_fields: additional_fields) == value)
+      end
+    end
+
+    def canonical(value)
+      value.downcase.gsub(/[^a-z0-9]/, '')
+    end
+
+    def assignment_pattern(additional_fields)
+      return DEFAULT_ASSIGNMENT_PATTERN if additional_fields.empty?
+
+      terms = (FIELDS + additional_fields).map { |field| Regexp.escape(field) }.join('|')
+      Regexp.new("\\b(#{terms})\\b([\"']?\\s*[:=]\\s*)#{ASSIGNMENT_VALUE_PATTERN}", Regexp::IGNORECASE)
+    end
+
+    def sensitive_key?(key, fields)
+      segments = key.gsub(/([a-z0-9])([A-Z])/, '\\1_\\2').downcase.split(/[^a-z0-9]+/)
+      segments.each_index.any? do |start|
+        combined = +''
+        segments.drop(start).any? do |segment|
+          combined << segment
+          fields.include?(combined)
+        end
+      end
+    end
+
+    def visit(value, work, depth, structured)
+      work[:nodes] += 1
+      raise ArgumentError, 'budget_exceeded' if work[:nodes] > 4096
+      return REDACTED if depth > 16
+
+      case value
+      when String then string(value, work, structured)
+      when Hash, Array then collection(value, work, depth, structured)
+      when NilClass, TrueClass, FalseClass, Integer then value
+      when Float
+        raise ArgumentError, 'unsafe_input' unless value.finite?
+
+        value
+      else
+        raise ArgumentError, 'unsafe_input'
+      end
+    end
+
+    def collection(value, work, depth, structured)
+      marked = false
+      return '[Circular]' if work[:seen].key?(value)
+      return REDACTED if value.length > 256
+
+      work[:seen][value] = true
+      marked = true
+      if value.is_a?(Array)
+        value.map { |item| visit(item, work, depth + 1, structured) }
+      else
+        value.each_with_object({}) do |(key, nested), result|
+          raise ArgumentError, 'unsafe_input' unless key.is_a?(String) || key.is_a?(Symbol)
+
+          name = key.to_s
+          next if name.bytesize > 128
+
+          count_bytes(work, name)
+          next if scrub_text(name, work) != name
+
+          result[name] = sensitive_key?(name, work[:fields]) ? REDACTED : visit(nested, work, depth + 1, structured)
+        end
+      end
+    ensure
+      work[:seen].delete(value) if marked
+    end
+
+    def count_bytes(work, value)
+      work[:bytes] += value.bytesize
+      raise ArgumentError, 'budget_exceeded' if work[:bytes] > MAX_BYTES
+    end
+
+    def string(value, work, structured)
+      raise ArgumentError, 'unsafe_input' unless value.valid_encoding?
+      return REDACTED if value.bytesize > 16_384
+
+      count_bytes(work, value)
+      if structured && value.start_with?('{', '[')
+        begin
+          nested = JSON.parse(value, max_nesting: 17)
+          return JSON.generate(visit(nested, work, 0, false)) if nested.is_a?(Hash) || nested.is_a?(Array)
+        rescue JSON::ParserError
+          # Malformed structured content with a credential label is withheld below.
+        end
+      end
+      result = scrub_text(value, work)
+      return REDACTED if result == value && value.start_with?('{', '[') &&
+                         /(?:password|token|secret|authorization|cookie)["']?\s*[:=]/i.match?(value)
+
+      result
+    end
+
+    def valid_card?(candidate)
+      digits = candidate.delete(' -')
+      return false unless digits.length.between?(13, 19) && digits.chars.uniq.length > 1
+
+      digits.reverse.chars.each_with_index.sum do |char, index|
+        number = char.to_i * (index.odd? ? 2 : 1)
+        number > 9 ? number - 9 : number
+      end.modulo(10).zero?
+    end
+
+    def scrub_text(value, work, scan_urls: true)
+      return REDACTED if /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/i.match?(value) &&
+                         !/-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/i.match?(value)
+
+      result = value
+      if /(?:password|token|secret|authorization|cookie)%3[ad]/i.match?(result)
+        result = URI.decode_www_form_component(result)
+      end
+      pem = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/i
+      result = result.gsub(pem, REDACTED)
+      result = result.gsub(/\b(Authorization|Proxy-Authorization|Cookie|Set-Cookie)\s*:\s*[^\r\n]*/i, '\\1: [REDACTED]')
+      result = result.gsub(%r{\b(Bearer|Basic)\s+[A-Za-z0-9._~+/-]{6,}}i, '\\1 [REDACTED]')
+      result = result.gsub(/\bdbundle_(?:proj|mem|probe|agent)_[A-Za-z0-9_-]+\b/, REDACTED)
+      result = result.gsub(work[:assignment_pattern], '\\1\\2[REDACTED]')
+      result = result.gsub(/(?<![A-Za-z0-9_-])(?:[0-9][ -]?){12,18}[0-9](?![A-Za-z0-9_-])/) do |candidate|
+        valid_card?(candidate) ? REDACTED : candidate
+      end
+      return result unless scan_urls
+
+      result.gsub(%r{\bhttps?://[^\s<>"']+}i) do |candidate|
+        raw = candidate.sub(/[).,;]+\z/, '')
+        scrub_url(raw, work) + candidate.delete_prefix(raw)
+      end
+    rescue URI::InvalidURIError, ArgumentError
+      REDACTED
+    end
+
+    def scrub_url(raw, work)
+      uri = URI.parse(raw)
+      return REDACTED unless uri.host
+
+      if uri.userinfo
+        uri.user = 'REDACTED'
+        uri.password = nil
+      end
+      uri.path = '/' if uri.path.empty?
+      if uri.query
+        uri.query = URI.encode_www_form(URI.decode_www_form(uri.query).filter_map do |key, value|
+          next if key.bytesize > 128 || scrub_text(key, work, scan_urls: false) != key
+
+          unsafe = sensitive_key?(key, work[:fields]) || scrub_text(value, work, scan_urls: false) != value
+          [key, unsafe ? REDACTED : value]
+        end)
+      end
+      uri.fragment = nil
+      uri.to_s
+    rescue URI::InvalidURIError
+      REDACTED
+    end
+  end
+end

data/lib/debugbundle/version.rb

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

data/lib/debugbundle.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'debugbundle/redaction'
+require_relative 'debugbundle/telemetry_privacy'
 require_relative 'debugbundle/acknowledgement'
 require_relative 'debugbundle/before_send'
 require_relative 'debugbundle/rack/middleware'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: debugbundle
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0
 platform: ruby
 authors:
 - DebugBundle
 bindir: exe
 cert_chain: []
-date: 2026-09-15 00:00:00.000000000 Z
+date: 2026-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -44,17 +44,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Gemfile
 - LICENSE
-- Makefile
 - README.md
-- debugbundle.gemspec
 - lib/debugbundle.rb
 - lib/debugbundle/acknowledgement.rb
 - lib/debugbundle/before_send.rb
 - lib/debugbundle/client.rb
 - lib/debugbundle/client_event_support.rb
+- lib/debugbundle/client_process_support.rb
+- lib/debugbundle/client_queue_support.rb
 - lib/debugbundle/config.rb
+- lib/debugbundle/config_worker.rb
+- lib/debugbundle/delivery_worker.rb
 - lib/debugbundle/logging.rb
 - lib/debugbundle/rack/middleware.rb
 - lib/debugbundle/rack/relay_middleware.rb
@@ -66,29 +67,13 @@ files:
 - lib/debugbundle/relay/handler.rb
 - lib/debugbundle/remote_config.rb
 - lib/debugbundle/runtime.rb
+- lib/debugbundle/safe_input.rb
 - lib/debugbundle/sidekiq/server_middleware.rb
 - lib/debugbundle/suppression.rb
+- lib/debugbundle/telemetry_privacy.rb
 - lib/debugbundle/transport.rb
 - lib/debugbundle/trigger_token.rb
 - lib/debugbundle/version.rb
-- spec/before_send_spec.rb
-- spec/client_spec.rb
-- spec/debugbundle_spec.rb
-- spec/file_transport_spec.rb
-- spec/fixtures/event-envelope.schema.json
-- spec/logger_integration_spec.rb
-- spec/rack_integration_spec.rb
-- spec/rack_middleware_spec.rb
-- spec/rails_railtie_spec.rb
-- spec/rails_relay_spec.rb
-- spec/redaction_spec.rb
-- spec/relay_spec.rb
-- spec/remote_config_spec.rb
-- spec/repository_metadata_spec.rb
-- spec/sidekiq_integration_spec.rb
-- spec/sidekiq_middleware_spec.rb
-- spec/spec_helper.rb
-- spec/suppression_spec.rb
 homepage: https://debugbundle.com/docs/sdks/ruby
 licenses:
 - Apache-2.0

data/Gemfile

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gemspec
-
-group :development, :test do
-  gem 'json_schemer', '~> 2.4'
-  gem 'rack-test', '~> 2.1'
-  gem 'rails', '~> 7.1'
-  gem 'rake', '~> 13.2'
-  gem 'rspec', '~> 3.13'
-  gem 'rubocop', '~> 1.76', require: false
-  gem 'sidekiq', '~> 7.0', require: false
-  gem 'simplecov', '~> 0.22', require: false
-  gem 'webmock', '~> 3.25'
-end

data/Makefile

@@ -1,58 +0,0 @@
-SHELL := /bin/sh
-
-RUBY_IMAGE ?= ruby:3.4.2
-WORKDIR := /workspace
-BUNDLE_GEMFILE ?= Gemfile
-VERSION ?= $(shell ruby -e 'require "./lib/debugbundle/version"; print DebugBundle::VERSION')
-
-DOCKER_RUN = docker run --rm -t \
-	-v "$(PWD):$(WORKDIR)" \
-	-w "$(WORKDIR)" \
-	$(RUBY_IMAGE)
-
-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"
-
-test:
-	$(DOCKER_RUN) sh -lc "$(BUNDLE_ENV) bundle config set path vendor/bundle && $(BUNDLE_ENV) bundle install && $(BUNDLE_ENV) bundle exec rspec"
-
-lint:
-	$(DOCKER_RUN) sh -lc "$(BUNDLE_ENV) bundle config set path vendor/bundle && $(BUNDLE_ENV) bundle install && $(BUNDLE_ENV) bundle exec rubocop"
-
-build:
-	$(DOCKER_RUN) sh -lc "$(BUNDLE_ENV) bundle config set path vendor/bundle && $(BUNDLE_ENV) bundle install && gem build debugbundle.gemspec"
-
-smoke:
-	$(DOCKER_RUN) sh -lc "gem build debugbundle.gemspec && ruby smoke/run_app_driven_smoke.rb --source local --version $(VERSION)"
-
-smoke-published:
-	$(DOCKER_RUN) sh -lc "ruby smoke/run_app_driven_smoke.rb --source published --version $(VERSION)"
-
-compat-rack:
-	docker run --rm -t -v "$(PWD):$(WORKDIR)" -w "$(WORKDIR)" ruby:3.1.6 sh -lc 'SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rack_2_2.gemfile" bundle config set path vendor/bundle && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rack_2_2.gemfile" bundle install && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rack_2_2.gemfile" bundle exec rspec spec/rack_integration_spec.rb spec/rack_middleware_spec.rb spec/relay_spec.rb'
-	docker run --rm -t -v "$(PWD):$(WORKDIR)" -w "$(WORKDIR)" ruby:3.4.2 sh -lc 'SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rack_3.gemfile" bundle config set path vendor/bundle && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rack_3.gemfile" bundle install && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rack_3.gemfile" bundle exec rspec spec/rack_integration_spec.rb spec/rack_middleware_spec.rb spec/relay_spec.rb'
-
-compat-rails:
-	docker run --rm -t -v "$(PWD):$(WORKDIR)" -w "$(WORKDIR)" ruby:3.1.6 sh -lc 'SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rails_7_0.gemfile" bundle config set path vendor/bundle && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rails_7_0.gemfile" bundle install && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rails_7_0.gemfile" bundle exec rspec spec/rails_relay_spec.rb spec/rails_railtie_spec.rb'
-	docker run --rm -t -v "$(PWD):$(WORKDIR)" -w "$(WORKDIR)" ruby:3.4.2 sh -lc 'SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rails_7_1.gemfile" bundle config set path vendor/bundle && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rails_7_1.gemfile" bundle install && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/rails_7_1.gemfile" bundle exec rspec spec/rails_relay_spec.rb spec/rails_railtie_spec.rb'
-
-compat-sidekiq:
-	docker run --rm -t -v "$(PWD):$(WORKDIR)" -w "$(WORKDIR)" ruby:3.2 sh -lc 'SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/sidekiq_7.gemfile" bundle config set path vendor/bundle && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/sidekiq_7.gemfile" bundle install && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/sidekiq_7.gemfile" bundle exec rspec spec/sidekiq_middleware_spec.rb spec/sidekiq_integration_spec.rb'
-	docker run --rm -t -v "$(PWD):$(WORKDIR)" -w "$(WORKDIR)" ruby:3.4.2 sh -lc 'SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/sidekiq_8.gemfile" bundle config set path vendor/bundle && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/sidekiq_8.gemfile" bundle install && SIMPLECOV_MINIMUM_COVERAGE=0 BUNDLE_GEMFILE="gemfiles/sidekiq_8.gemfile" bundle exec rspec spec/sidekiq_middleware_spec.rb spec/sidekiq_integration_spec.rb'
-
-compat: compat-rack compat-rails compat-sidekiq
-
-shell:
-	$(DOCKER_RUN) sh

data/debugbundle.gemspec

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/debugbundle/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'debugbundle'
-  spec.version = DebugBundle::VERSION
-  spec.authors = ['DebugBundle']
-  spec.email = ['support@debugbundle.com']
-
-  spec.summary = 'DebugBundle SDK for Ruby'
-  spec.description = 'Production-ready error, request, log, and probe capture for Ruby services.'
-  spec.homepage = 'https://debugbundle.com/docs/sdks/ruby'
-  spec.license = 'Apache-2.0'
-  spec.required_ruby_version = '>= 3.1'
-
-  spec.metadata = {
-    'homepage_uri' => spec.homepage,
-    'source_code_uri' => 'https://github.com/debugbundle/debugbundle-ruby',
-    'changelog_uri' => 'https://github.com/debugbundle/debugbundle-ruby/blob/main/CHANGELOG.md',
-    'rubygems_mfa_required' => 'true'
-  }
-
-  spec.files = Dir.glob('{lib,spec}/**/*') + %w[Gemfile Makefile README.md LICENSE debugbundle.gemspec]
-  spec.bindir = 'exe'
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'base64', '~> 0.2'
-  spec.add_dependency 'logger', '~> 1.6'
-end

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