foam-otel 1.9.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27bb6b38712364503503fecd37ea383f9a7e3fb3648da8ef41524c575ef9302
-  data.tar.gz: 0c9fee962999043120904c8ffe85621e32ae04fcb300280ec8af0b2c77291a0d
+  metadata.gz: a2e506ae900650923638df263e5775efa20dd8ab7a63540eefb9d5156c1d008c
+  data.tar.gz: 64ea4091c85c9541ec1f08dd5560608e560ec80e8ee6918f95098b976b0ec82e
 SHA512:
-  metadata.gz: 8bdcb84ca5d9becc44e9a181512ac19c9c8c24f5035e7da9da09a1ab59a4c09cd96b9cde80a8b5d073001ae6f36d9f4e1b3e1a3e640c4eafa6d30ac34800e47c
-  data.tar.gz: b09d59343870e8d16ef9e4c0794e7ec78486d5ab9c3eea339d99c4f8b4fa46f58ca5246ca3df70ed8a82c795fd4108c296c3bb19e720640c5acce080f0e90a98
+  metadata.gz: 4c776696c10dc442394e5b023db7b47d178ec4b328addd693ba72b60e726c19f923533f0f1645e7b62ec322e63d6fcd0b39b1ca917cd9aa66403295c0b67e266
+  data.tar.gz: 615ec0ee4400e6e11baa6a6572fcafdccdeb6764f9bb2e65afcf4ff72a8185e9ba45086cd5e8e039934ea1043fe165d94784983539ac0d3e361a6b28f72a986e

data/README.md

@@ -672,6 +672,11 @@ The per-record contract (Sentry `beforeSend` semantics):
   in place, they are shared structures. Foam re-normalizes the record's
   `total_recorded_*` bookkeeping after your hooks run, so adding/deleting
   attributes never corrupts the wire's dropped-count accounting.
+  `record.resource` and `record.instrumentation_scope` are **identity, not
+  payload**: read them freely, but edits and replacements are discarded —
+  the original identity objects always ship (they are process-global and
+  the encoder groups by them; a writable resource would also bypass
+  redaction, which never masks resource attributes).
 * **return `nil`** → the record is dropped, silently (that is the filter
   mechanism, not an error).
 * **raise, or return a foreign object** → that record is dropped

data/lib/foam/otel/before_send.rb

@@ -62,6 +62,7 @@ module Foam
       # flood an adversary-shaped record stream controls — rule 15's
       # "loud but never a flood" posture).
       def run(hooks, record, signal, faults)
+        identity = identity_of(record)
         current, counters = thaw(record)
         hooks.each do |hook|
           result = hook.call(current)
@@ -74,6 +75,7 @@ module Foam
           current = result
         end
         restore_counters!(current, counters)
+        restore_identity!(current, identity)
         current
       rescue StandardError, SystemStackError => e
         faults << e.class.name
@@ -110,9 +112,43 @@ module Foam
           copy.attributes = attributes.nil? ? {} : attributes.transform_values { |v| thaw_value(v) }
         end
         copy.body = thaw_body(copy.body) if copy.respond_to?(:body) && copy.respond_to?(:body=)
+        # The scope handed to the hook is a COPY: InstrumentationScope is a
+        # mutable Struct, and an in-place `scope.name =` on the shared
+        # object would corrupt process-global identity (see identity_of).
+        if copy.respond_to?(:instrumentation_scope) && copy.respond_to?(:instrumentation_scope=)
+          copy.instrumentation_scope = copy.instrumentation_scope&.dup
+        end
         [copy, sdk_drop_counters(record)]
       end
 
+      # resource / instrumentation_scope are process-global IDENTITY objects
+      # shared by every record the tracer/logger emits — and Ruby's
+      # InstrumentationScope is a plain MUTABLE Struct. A hook that renames
+      # the scope would corrupt the identity of EVERY subsequent span/log
+      # from that instrument (proven live in the 2026-07-29 retro-probe),
+      # and a wholesale `record.resource =` replacement would ship
+      # hook-authored resource attributes RAW — redaction never masks
+      # resource, so that path could widen what ships. Both are closed the
+      # way the Go port does it: identity always comes from the ORIGINAL
+      # record — captured here, force-restored onto the survivor after the
+      # pipeline (hook edits to identity are discarded; the encoder's
+      # group-by-identity stays intact). Documented in the README:
+      # resource/instrumentation_scope are informational, not hook-writable.
+      def identity_of(record)
+        {
+          resource: (record.resource if record.respond_to?(:resource)),
+          scope: (record.instrumentation_scope if record.respond_to?(:instrumentation_scope)),
+        }
+      end
+
+      def restore_identity!(record, identity)
+        record.resource = identity[:resource] if record.respond_to?(:resource=)
+        if record.respond_to?(:instrumentation_scope=)
+          record.instrumentation_scope = identity[:scope]
+        end
+        record
+      end
+
       def thaw_value(value)
         case value
         when String then value.dup

data/lib/foam/otel/version.rb

@@ -175,6 +175,17 @@ module Foam
     #   case) install NOTHING. Proven against the real agents in
     #   test-apps/ruby-coexistence (six vendors, both patch mechanisms,
     #   patched-client probe REQUIRED green).
-    VERSION = "1.9.0"
+    # 1.9.1: before_send IDENTITY RESTORE (retro-probe class 14; PATCH —
+    #   bugfix-only). resource / instrumentation_scope are process-global
+    #   identity objects, and InstrumentationScope is a MUTABLE Struct: a
+    #   hook renaming it corrupted the identity of every subsequent
+    #   span/log from that instrument (proven live), and a wholesale
+    #   `record.resource =` replacement shipped hook-authored resource
+    #   attributes RAW (redaction never masks resource — the one
+    #   can-never-widen gap). Hooks now receive a COPIED scope, and the
+    #   ORIGINAL resource/scope are force-restored onto every survivor
+    #   after the pipeline (identity is not hook-writable — the Go port's
+    #   contract; README updated).
+    VERSION = "1.9.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foam-otel
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.9.1
 platform: ruby
 authors:
 - Foam