condux 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '095069e5d14a6e32c481494fb6927c19441f56cc0a9cdc9dd6311acd9ef7e7c9'
-  data.tar.gz: 1b3db61a8413e8fab802e39c13317b77c3418277b7f9a5b1c083b762cc64ba86
+  metadata.gz: 985adaf0c8807f4c03e4c83b2d4969bf37d505f7abba46d06cbb6de95bb83ff5
+  data.tar.gz: 466b2a9ddcdc2056a6bf38db174fabad21c3a920f6e3bea090c1a4b0bda493e2
 SHA512:
-  metadata.gz: 5b12b5ffdee576bb9879191e5ba68748ce9a7b9cb81843422ce10b567d15776616d156cfcc1de0b3b8afb1caef5fec53501316d8d8a44e960ad78aa8f45eef9c
-  data.tar.gz: 5ea29b8ae01b6f994d62b3b5af926d66a41878ae444f927fba82f05ab7d3cf03ab1f3c5db3e6a1ab8a158be2cfef7ec6132ac581f180d1f6859615260fbe5f37
+  metadata.gz: a638998e2b15a3f7c90c1c8c632ee8c400892ad848aeba80a4361eec7d178e2b5add4a00057c393042dded2b32d5244f2ae55958efad1c5c6aab7d3eb9256081
+  data.tar.gz: 6513420fa59559a2e5cee3237d6c91ed254342d45110348a18a15b4feab59924214c87c21823e84551803a73f85c752c0c000706cd1e0f7e33ecf4cedcff1ef4

data/README.md

@@ -92,12 +92,27 @@ Condux.capture_exception(error, request: { "url" => "/api/sync" }, tags: { "job"
 require "condux/rack"
 use Condux::Rack::CaptureExceptions
 
-# Rails (config/application.rb)
-config.middleware.use "Condux::Rack::CaptureExceptions"
+# Rails (config/application.rb), the require at the top of the file
+require "condux/rack"
+config.middleware.use Condux::Rack::CaptureExceptions
 ```
 
 Uncaught exceptions are reported as unhandled and re-raised, so the app's own error handling still runs.
 
+**On Rails, caller-caused exceptions are re-raised but not reported.** Rails already classifies them:
+`ActionDispatch::ExceptionWrapper.rescue_responses` maps an exception class to a status, and anything it
+answers with a 4xx describes what the client sent rather than a defect in your app. A malformed JSON
+body and a bad percent-encoded query both land there, and anyone can send those at will, so filing them
+would let a stranger bury your real errors. Add your own with
+`config.action_dispatch.rescue_responses`, which Condux reads too, so one setting governs your error
+pages and your reporting together. Anything Rails does not classify still reports, since the registry
+defaults to 500. Under bare Rack there is no such registry, so nothing is filtered.
+
+**Pass the class, not its name as a string.** Rails builds each middleware with `klass.new(app)`, so a
+string aborts boot with `undefined method 'new' for an instance of String`. Rails deprecated string
+middleware in 5.0 and removed it in 5.1, so no supported version accepts it. The `require` matters too:
+Bundler loads `condux`, which does not define `Condux::Rack`.
+
 **On Rails use `config.middleware.use`, and nothing else.** `use` appends, which puts the middleware at
 the bottom of the stack, inside `ActionDispatch::ShowExceptions`. That position is why it works:
 `ShowExceptions` catches a controller exception and turns it into a 500, so anything above it never sees

data/lib/condux/client.rb

@@ -13,12 +13,14 @@ module Condux
   class Client
     DEFAULT_MAX_RETRIES = 3
 
-    def initialize(dsn:, environment:, release:, max_retries:, transport:, sleep:, clock:)
+    def initialize(dsn:, environment:, release:, max_retries:, transport:, sleep:, clock:,
+                   send_modules: true)
       parsed = Dsn.parse(dsn)
       @transport = EventTransport.new(parsed.store_url, parsed.public_key, max_retries, transport, sleep)
       @environment = environment
       @release = release
       @clock = clock || -> { Time.now }
+      @send_modules = send_modules
     end
 
     # +request+ (url/method/query_string) and +tags+ describe this one event. They are passed here
@@ -43,6 +45,9 @@ module Condux
         "platform" => "ruby",
         "level" => level,
       }.merge(Scope.fields)
+      # The runtime dependency inventory (ADR-0041). Collected HERE rather than at init because
+      # Gem.loaded_specs reports activated gems, and at boot almost nothing is activated yet.
+      event.merge!(Modules.fields(event["timestamp"])) if @send_modules
       event["request"] = request if request && !request.empty?
       # Merged over the ambient tags rather than replacing them, so a per-event tag cannot silently drop
       # the deployment-wide ones.

data/lib/condux/modules.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Condux
+  # The runtime dependency inventory that rides events (ADR-0041): which gem versions are actually
+  # loaded, as opposed to which ones a Gemfile declares. The relay indexes this so a security advisory
+  # can be answered with "and you are running 2.3.0 in production" rather than only "your lockfile
+  # says so".
+  #
+  # <b>This one is collected lazily, unlike the other SDKs, and that is not an inconsistency.</b>
+  # Gem.loaded_specs reports the gems that have been ACTIVATED, not the ones installed. Measured in a
+  # bare interpreter it holds a single entry, because nothing has been required yet. Collecting during
+  # Condux.init, which an application typically calls early in boot, would therefore report almost
+  # nothing. Collecting at capture time reports what was genuinely loaded by the moment the error
+  # happened, which is both correct and the truest reading of what this feature claims to measure. It
+  # costs nothing: loaded_specs is an in-memory hash, with no filesystem behind it.
+  module Modules
+    # The most entries carried on one event. The cap applies after sorting, so which entries survive is
+    # stable across events rather than varying with hash order: the server sees one consistent set
+    # instead of a shifting sample.
+    MAX_MODULES = 1000
+
+    # How long to wait before repeating the inventory on another event.
+    #
+    # This is what makes the feature affordable. The server deduplicates a release's inventory down to
+    # one row per package per day, so attaching the whole map to every event would spend bytes for
+    # nothing. Repeating on an interval rather than sending once keeps the robustness that every-event
+    # buys: the event carrying the inventory can be dropped by a rate limit or a quota rejection
+    # before anything parses it, so a single attempt per process would lose that day's inventory.
+    MODULES_INTERVAL_SECONDS = 15 * 60
+
+    module_function
+
+    # The loaded gems as a name to version hash, empty when they cannot be read.
+    #
+    # Never raises. This runs inside capture, which is already handling somebody's error, so a broken
+    # spec costs that entry and nothing else.
+    def collect
+      found = {}
+      Gem.loaded_specs.each do |name, spec|
+        version = spec.version.to_s
+        found[name.to_s] = version if name && !name.to_s.empty? && !version.empty?
+      rescue StandardError
+        # One unreadable spec is not a reason to report nothing about the rest.
+        next
+      end
+      found
+    rescue StandardError, NameError
+      # No RubyGems at all (a packaged binary, a trimmed runtime). Unknown is the honest answer.
+      {}
+    end
+
+    # The inventory's contribution to an event: the full map on the first event and then at most once
+    # per MODULES_INTERVAL_SECONDS, and an empty hash otherwise, so an event that carries nothing keeps
+    # its exact previous wire shape.
+    def fields(now)
+      return {} if @last_attached_at && (now - @last_attached_at) < MODULES_INTERVAL_SECONDS
+
+      loaded = collect
+      return {} if loaded.empty?
+
+      @last_attached_at = now
+      { "modules" => loaded.sort.first(MAX_MODULES).to_h }
+    end
+
+    # Reset the interval. Tests only; a process loads its gems once.
+    def reset
+      @last_attached_at = nil
+    end
+  end
+end

data/lib/condux/rack.rb

@@ -11,8 +11,15 @@ module Condux
     #   require "condux/rack"
     #   use Condux::Rack::CaptureExceptions
     #
-    #   # Rails (config/application.rb)
-    #   config.middleware.use "Condux::Rack::CaptureExceptions"
+    #   # Rails (config/application.rb), the require at the top of the file
+    #   require "condux/rack"
+    #   config.middleware.use Condux::Rack::CaptureExceptions
+    #
+    # PASS THE CLASS, NOT ITS NAME AS A STRING. Rails builds each entry with `klass.new(app)`, so a
+    # String argument aborts boot with `undefined method 'new' for an instance of String`. Rails
+    # deprecated string middleware in 5.0 and removed the constantize in 5.1, so there is no supported
+    # version where the string form works. The require is needed too: Bundler loads `condux`, which
+    # does not define `Condux::Rack`, and without it boot fails on an uninitialized constant.
     #
     # ON RAILS, USE `config.middleware.use` AND NOTHING ELSE.
     #
@@ -36,12 +43,35 @@ module Condux
         # left to process state.
         Condux.request_scope do
           @app.call(env)
-        rescue StandardError => e # report anything the app raises, then re-raise
-          Condux.capture_exception(e, handled: false, request: self.class.request_fields(env))
+        rescue StandardError => e # report what the app got wrong, then re-raise whatever it was
+          unless self.class.caller_caused?(e)
+            Condux.capture_exception(e, handled: false, request: self.class.request_fields(env))
+          end
           raise
         end
       end
 
+      # True when the framework classifies this exception as the CALLER's mistake, not the app's.
+      #
+      # Rails keeps that classification in ActionDispatch::ExceptionWrapper.rescue_responses, a public
+      # registry of exception class name to status. Asking it means there is no list of our own to keep
+      # extending, and `config.action_dispatch.rescue_responses` merges into the same registry, so an
+      # app's own classifications are honoured with no API from us.
+      #
+      # The registry defaults to :internal_server_error, so anything Rails does not recognise still
+      # reports: the rule fails toward reporting rather than toward silence. Measured against Rails
+      # 8.1.3.1, it answers 500 for an unknown class, an empty string and nil, and raises for none of
+      # them, which is why there is no defensive rescue here to go stale.
+      #
+      # Bare Rack has no equivalent registry, so with ActionDispatch absent nothing is filtered and the
+      # behaviour is exactly as before. See ADR-0044.
+      def self.caller_caused?(error)
+        return false unless defined?(ActionDispatch::ExceptionWrapper)
+
+        status = ActionDispatch::ExceptionWrapper.status_code_for_exception(error.class.name)
+        status.is_a?(Integer) && status >= 400 && status < 500
+      end
+
       # The request, in the Sentry store shape the relay parses.
       #
       # Deliberately only the path, method and query string. Rack puts headers in HTTP_* keys, including

data/lib/condux.rb

@@ -2,6 +2,7 @@
 
 require_relative "condux/level"
 require_relative "condux/send_result"
+require_relative "condux/modules"
 require_relative "condux/scope"
 require_relative "condux/client"
 
@@ -17,9 +18,13 @@ module Condux
     # Configure the SDK with a project DSN (and optional testing hooks). Raises on a malformed DSN:
     # setup runs once at developer time, so a typo is worth failing loudly for.
     def init(dsn:, environment: nil, release: nil, max_retries: Client::DEFAULT_MAX_RETRIES,
-             transport: nil, sleep: nil, clock: nil)
+             transport: nil, sleep: nil, clock: nil, send_modules: true)
       @client = Client.new(dsn: dsn, environment: environment, release: release,
-                           max_retries: max_retries, transport: transport, sleep: sleep, clock: clock)
+                           max_retries: max_retries, transport: transport, sleep: sleep, clock: clock,
+                           send_modules: send_modules)
+      # A re-init starts the interval afresh, so a new client does not inherit the previous one's
+      # "already sent recently" state and skip its first event.
+      Modules.reset
     end
 
     # Report an exception as an error-level event, with its stack trace. Never raises on delivery failure.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: condux
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Condux
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-16 00:00:00.000000000 Z
+date: 2026-09-06 00:00:00.000000000 Z
 dependencies: []
 description: 'The Condux SDK for Ruby: report errors to a Condux relay with a resilient,
   never-raising transport. Zero runtime dependencies (standard library only).'
@@ -27,6 +27,7 @@ files:
 - lib/condux/event_payload.rb
 - lib/condux/event_transport.rb
 - lib/condux/level.rb
+- lib/condux/modules.rb
 - lib/condux/rack.rb
 - lib/condux/scope.rb
 - lib/condux/send_result.rb