debugbundle 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b248dcbd96eccb5c6feb9720d0d68d91377469fc2a69e722f5ee665ac6b963b9
-  data.tar.gz: dd58681087f077b40b9a1d9efd6608f0f8ef9680bf1ca08cca3a382bd07811a1
+  metadata.gz: 8f8040734d7a652566f0c06328713b3b7fa5bc559b1e30f1432c45b71f8decab
+  data.tar.gz: b53fba03cb4013cb375610e1e9acef0264f79cc87ad98c987b72ae1968e9a411
 SHA512:
-  metadata.gz: e2c64054d0bee13e76b6e231102e9d8b13cd0806c03a82c7ba09b24e6baf8195ce2163022d7b7855041fd8939fb889dc0f3559f03188d340db793b7f320361d5
-  data.tar.gz: 02d6185279a906a1d3ce16bca8a6bc14359eecee788f89f5e8cd5c2c5844a2390e08e403ed9e750362fdf89c9152ca246930f469622898f7b97bdcfc72723094
+  metadata.gz: e76d4d31fb538e7a9261b3a544e51440f9406c4ba3fc61508dd34477052e84d4036955568188f1baf988c6a30c30fa8fdbe08d4f286a26131adac3f9ef0f26aa
+  data.tar.gz: 64d7f18d44af78e8bd267fde9b967996d90b308efc0df021fa3d1cc2205f0cad69929a9b896ad5819df0ee4618ca399f9f6229dd372ce956e50397e770cd3db0

data/README.md

@@ -4,6 +4,12 @@ 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.
 
+The source test matrix covers Ruby 3.1 through 4.0. Rails 7.x remains an installed-base lane; the current Rails 8.1 lane exercises the relay and Rack middleware on Ruby 4.0.
+
+## 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 +320,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.5.0
 ```
 
 `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/client.rb

@@ -212,7 +212,12 @@ module DebugBundle
     end
 
     def set_context(key, value)
-      @context[key.to_s] = @redactor.redact_value(value)
+      safe = TelemetryPrivacy.protect(
+        { key.to_s => @redactor.redact_value(value) }, additional_fields: config.redact_fields
+      )
+      @context[key.to_s] = safe[key.to_s] if safe.key?(key.to_s)
+      value
+    rescue StandardError
       value
     end
 
@@ -238,17 +243,20 @@ module DebugBundle
       resolved, raw_value = resolve_probe_value(data, block)
       return unless resolved
 
+      safe_label = TelemetryPrivacy.protect(label.to_s, additional_fields: config.redact_fields)
       entry = {
-        'label' => label.to_s,
+        'label' => safe_label,
         'data' => normalize_probe_data(raw_value),
         'timestamp' => now.iso8601
       }
 
-      bucket = (@probe_buffers[label.to_s] ||= [])
+      bucket = (@probe_buffers[safe_label] ||= [])
       bucket << entry
       bucket.shift while bucket.length > config.max_probe_entries_per_label
 
-      emit_probe_events(label.to_s, entry['data'], matching_directives)
+      emit_probe_events(safe_label, entry['data'], matching_directives)
+    rescue StandardError
+      nil
     end
 
     def capture_exceptions

data/lib/debugbundle/client_event_support.rb

@@ -74,15 +74,23 @@ module DebugBundle
       end
 
       def normalize_probe_data(value)
-        redacted = @redactor.redact_value(value)
+        redacted = TelemetryPrivacy.protect(@redactor.redact_value(value), additional_fields: config.redact_fields)
         redacted.is_a?(Hash) ? redacted : { 'value' => redacted }
+      rescue StandardError
+        { 'value' => '[REDACTED]' }
       end
 
       def apply_before_send(event)
-        BeforeSend.apply(event, config.before_send)
+        protected = protect_event(event)
+        return nil unless protected
+
+        prepared = BeforeSend.apply(protected, config.before_send)
+        prepared && protect_event(prepared)
       end
 
       def enqueue_event(event)
+        event = protect_event(event)
+        return unless event
         return unless sampled_in?
 
         @buffer_mutex.synchronize do
@@ -91,6 +99,23 @@ module DebugBundle
         end
       end
 
+      def protect_event(event)
+        return nil unless TelemetryPrivacy.safe_event_identity?(event, additional_fields: config.redact_fields)
+
+        fields = TelemetryPrivacy.protect(
+          { 'service' => event['service'], 'payload' => event['payload'], 'context' => event['context'] },
+          additional_fields: config.redact_fields
+        )
+        return nil unless fields['service'].is_a?(Hash) && fields['payload'].is_a?(Hash)
+        return nil unless fields['service']['name'].is_a?(String) && fields['service']['environment'].is_a?(String)
+
+        event.merge('service' => fields['service'], 'payload' => fields['payload']).tap do |protected|
+          protected['context'] = fields['context'] if event.key?('context')
+        end
+      rescue StandardError
+        nil
+      end
+
       def buffered_batch
         @buffer_mutex.synchronize { @buffer.dup }
       end

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/rack/middleware.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cgi'
+require 'uri'
 
 module DebugBundle
   module Rack
@@ -65,9 +65,19 @@ module DebugBundle
       end
 
       def parse_query(query_string)
-        CGI.parse(query_string.to_s).transform_values do |values|
-          values.length == 1 ? values.first : values
+        raw_query = query_string.to_s
+        return {} if raw_query.bytesize > 16_384
+
+        URI.decode_www_form(raw_query.tr(';', '&')).each_with_object({}) do |(key, value), result|
+          result[key] = if result.key?(key)
+                          Array(result[key]) << value
+                        else
+                          value
+                        end
         end
+      rescue StandardError
+        # Broken request metadata must never interrupt the host application.
+        {}
       end
 
       def route_template(env)

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/telemetry_privacy.rb

@@ -0,0 +1,194 @@
+# 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
+
+    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 }
+      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 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)
+      (FIELDS + work[:extra]).each do |field|
+        pattern = /\b(#{Regexp.escape(field)})\b(["']?\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s&,;]+)/i
+        result = result.gsub(pattern, '\\1\\2[REDACTED]')
+      end
+      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.0'
+  VERSION = '1.5.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.0
+  version: 1.5.0
 platform: ruby
 authors:
 - DebugBundle
 bindir: exe
 cert_chain: []
-date: 2026-09-12 00:00:00.000000000 Z
+date: 2026-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -44,11 +44,8 @@ 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
@@ -68,27 +65,10 @@ files:
 - lib/debugbundle/runtime.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,52 +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
-
-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