foam-otel 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65833871aff8351bab7083f4a9d636afd5704cd1327e95bc4af117437d12ad85
-  data.tar.gz: 206b1b6bfe1633b44267283c775b63ae47cd429be0bc9260c27ab89fd4f8b6ed
+  metadata.gz: 894986849774ca1e6ee37ed18eccb168fe0b026a438abdd53432b46a5de4b9d4
+  data.tar.gz: c59a29ea7223dc7a92500303a2615d03d048fcf70927c12e37250d21a8785f57
 SHA512:
-  metadata.gz: c7c97cf55df3769670636aab31b8dafa53ee8975b4648bd1339e167f5af63245609355b547e25eefcaefd68f155e8e5934e739a54f012a5137231f343a966a2e
-  data.tar.gz: eb600f006bdce6aabf407e8b7df5f1e2fe7ece7a7f7590ac956689a6d1c148e0b5a1d32a4095606608d931f3792a908bb901fe06f804e49f52eda366b6e97650
+  metadata.gz: 5cddf45218f81f9c18ab2557c7737a53da552bdf429524e6ef1f1cb64fbc84e19757de30d370e6e1217cf2a5217d271b3c4a19b6b8610d36f1846699e96a2cf6
+  data.tar.gz: 2199d01ee1f3cb89ae50d721ad6110c6c803256ac5093ba81dfc070e8cdb3af460ff13d653e6f9dd307f5a5005673e178693ca5a630459e698adc7e29a00b76e

data/GOTCHAS.md

@@ -971,10 +971,13 @@ exfiltratable — the value-pattern secret layer is the required second control
   foam's promise is coexistence: the app must keep working.
   THE SAME COLLISION EXISTS ON A SECOND CLASS: dd-trace-rb's httprb patch
   and the contrib `opentelemetry-instrumentation-http` patch both define
-  `annotate_span_with_response!` on `HTTP::Client` (3-arg vs 2-arg) —
-  upstream tracks the combination as unsupported (dd-trace-rb#3575,
-  opentelemetry-ruby#1625, httprb/http#838). A `datadog/auto_instrument` +
+  `annotate_span_with_response!` on `HTTP::Client` (3-arg vs 2-arg) — the
+  colliding definitions verified at source (below). A
+  `datadog/auto_instrument` +
   contrib-http process crashes every HTTP.rb request the same way.
+  (The upstream issue numbers the introducing PR cited for this twin could
+  NOT be verified as tracking it and are withdrawn — the colliding source
+  definitions are the primary evidence.)
 - **Sources**:
   - Installed source — the two colliding definitions:
     opentelemetry-instrumentation-net_http 0.29.0
@@ -986,11 +989,9 @@ exfiltratable — the value-pattern secret layer is the required second control
   - The HTTP::Client twin: dd-trace-rb
     `lib/datadog/tracing/contrib/httprb/instrumentation.rb`
     (3-arg `annotate_span_with_response!(span, response, options)`) vs
-    contrib opentelemetry-instrumentation-http `patches/client.rb`
-    (2-arg); upstream reports
-    https://github.com/DataDog/dd-trace-rb/issues/3575 ,
-    https://github.com/open-telemetry/opentelemetry-ruby/issues/1625 ,
-    https://github.com/httprb/http/issues/838 .
+    contrib opentelemetry-instrumentation-http
+    `lib/opentelemetry/instrumentation/http/patches/stable/client.rb`
+    (2-arg) — both definitions verified at source.
   - Ruby semantics: prepended modules join the class's ancestor chain and
     private methods resolve through the SAME chain for every caller — there
     is no per-module helper namespace.

data/lib/foam/otel/llm/http_anthropic_shim.rb

@@ -141,23 +141,42 @@ module Foam
 
           # Reads the finished JSON body for capture WITHOUT taking anything
           # away from the app: only when the body is bounded (declared
-          # Content-Length within the cap) and a replacement Body can be
+          # Content-Length within the cap, no Content-Encoding — a gzip
+          # body's declared length is the COMPRESSED size, and the inflated
+          # stream could dwarf the cap) and a replacement Body can be
           # built (probed BEFORE consuming — if HTTP.rb's internals ever
           # drift, foam skips capture rather than risk the app's stream).
           # The drained bytes are re-wrapped in a fresh HTTP::Response::Body
           # over an EOF-compatible buffer and swapped back, so app-side
           # #to_s, #each and #readpartial behave exactly as if foam had
-          # never read the response.
+          # never read the response. A transport failure MID-READ is
+          # re-armed: the swapped-in body re-raises the ORIGINAL exception
+          # on the app's own read — never a misleading StateError. The read
+          # itself inherits the app's HTTP.rb timeout configuration (bytes
+          # are capped here; deadlines belong to the client's .timeout).
           def readable_json_body(response)
             length = content_length(response)
             return nil unless length&.positive? && length <= BODY_PARSE_BYTE_CAP
+            return nil if content_encoded?(response)
             return nil unless response.instance_variable_defined?(:@body)
             return nil unless build_body("") # constructor probe, pre-consumption
 
-            contents = response.body.to_s
-            replacement = build_body(contents)
-            response.instance_variable_set(:@body, replacement) if replacement
-            contents
+            contents = begin
+              response.body.to_s
+            rescue StandardError, SystemStackError => e
+              rearm_failed_body(response, e)
+              return nil
+            end
+            replacement = build_body(contents) ||
+                          build_body(contents.dup.force_encoding(Encoding::BINARY))
+            # No hand-back, no capture: foam never profits from a stream it
+            # failed to return to the app.
+            return nil unless replacement
+
+            response.instance_variable_set(:@body, replacement)
+            # Belt over the declared length: never parse more than the cap
+            # actually materialized (a lying Content-Length header).
+            contents.bytesize <= BODY_PARSE_BYTE_CAP ? contents : nil
           rescue StandardError
             nil
           end
@@ -169,11 +188,29 @@ module Foam
             nil
           end
 
+          def content_encoded?(response)
+            return false unless response.respond_to?(:headers)
+
+            encoding = response.headers["Content-Encoding"].to_s
+            !encoding.empty? && encoding.downcase != "identity"
+          rescue StandardError
+            true # unknown => assume encoded, skip capture
+          end
+
           def build_body(contents)
             ::HTTP::Response::Body.new(BufferedBodyStream.new(contents), encoding: contents.encoding)
           rescue StandardError
             nil
           end
+
+          # A read that died under foam must die IDENTICALLY under the app:
+          # swap in a body whose reads re-raise the original transport error.
+          def rearm_failed_body(response, error)
+            replacement = ::HTTP::Response::Body.new(FailingBodyStream.new(error), encoding: Encoding::BINARY)
+            response.instance_variable_set(:@body, replacement)
+          rescue StandardError
+            nil
+          end
         end
 
         # Matches HTTP::Connection's readpartial contract (nil at EOF, never
@@ -192,6 +229,18 @@ module Foam
           end
         end
 
+        # Re-raises the transport error foam swallowed mid-capture, so the
+        # app's own read fails with the REAL exception class and message.
+        class FailingBodyStream
+          def initialize(error)
+            @error = error
+          end
+
+          def readpartial(*_args)
+            raise @error
+          end
+        end
+
         # Non-streaming JSON Message → response attributes; usage rides
         # {input_tokens, output_tokens} exactly like the SDK shim.
         RESPONSE = lambda do |response|
@@ -234,8 +283,8 @@ module Foam
 
         # Response attributes. The status code is stamped ONLY on the error
         # path (the observed error signal — fleet gen_ai spans carry no
-        # http.* on success; python removed exactly this success-path stamp
-        # as a deliberate wire correction). error.type carries the bare
+        # http.* on success, the posture python's gap-filler also converged
+        # on). error.type carries the bare
         # status string ("400"), matching the span status description and
         # semconv's well-known values — never an invented format.
         EXTRACTOR = lambda do |response|

data/lib/foam/otel/llm/ruby_openai_shim.rb

@@ -125,7 +125,9 @@ module Foam
           def embeddings(parameters: {})
             Foam::Otel::LLM.observe(
               provider: "openai", operation: "embeddings",
-              request: Foam::Otel::LLM.safe_request(provider: "openai") { RubyOpenAIShim.embeddings_request(parameters) },
+              request: Foam::Otel::LLM.safe_request(provider: "openai", operation: "embeddings") do
+                RubyOpenAIShim.embeddings_request(parameters)
+              end,
               response_extractor: RubyOpenAIShim::EMBEDDINGS_RESPONSE
             ) { super }
           end

data/lib/foam/otel/version.rb

@@ -238,12 +238,36 @@ module Foam
     #   contrib http patch define annotate_span_with_response! at
     #   non-identical signatures (3-arg vs 2-arg), the exact F18 Net::HTTP
     #   collision on a second class, live in the wild under
-    #   datadog/auto_instrument (upstream tracks it as unsupported:
-    #   dd-trace-rb#3575, opentelemetry-ruby#1625, httprb/http#838); the
+    #   datadog/auto_instrument (both colliding definitions verified at
+    #   source — GOTCHAS F18); the
     #   signature-dispatch shim lets both agents keep working WHEN both
     #   vendor patches precede foam's init-time scan (F18 residual:
     #   initialize foam after the vendor agents; a later-arriving patch is
     #   unshielded until a re-init/fork re-scan).
-    VERSION = "2.1.0"
+    # 2.1.1: LLM CAPTURE HARDENING + RESPONSE-STYLE MATRICES (PATCH — bug
+    #   fixes and tests only, no new surface). HttpAnthropicShim's body
+    #   capture: content-encoded (gzip) responses are never captured (the
+    #   declared Content-Length is the COMPRESSED size — the 32 KiB cap
+    #   could be bypassed by inflation; a post-materialization bytesize
+    #   guard also covers lying Content-Length); a transport failure DURING
+    #   capture now re-raises the ORIGINAL error on the app's own read
+    #   (was: a misleading HTTP::StateError); if the body hand-back cannot
+    #   be rebuilt, capture is skipped entirely. Degraded ruby-openai
+    #   embeddings spans keep gen_ai.operation.name="embeddings" (the
+    #   fallback stamped "chat" on a span named "embeddings openai").
+    #   GOTCHAS F18 citation hygiene: the three upstream issue links cited
+    #   for the HTTP::Client collision could not be verified and are
+    #   withdrawn; the colliding source definitions are the evidence.
+    #   Tests: full response-style matrices for both providers — every
+    #   documented Anthropic /v1/messages shape (parallel tool_use,
+    #   thinking/redacted_thinking, all stop_reasons incl.
+    #   model_context_window_exceeded, citation splitting, server-tool
+    #   round trips, error envelopes 400-529, non-object/invalid JSON) and
+    #   every documented OpenAI chat/embeddings shape (all finish_reasons
+    #   + unknown pass-through, parallel/custom/legacy tool calls,
+    #   refusal, n>1 choices, usage-detail variants, Faraday error
+    #   classes with observed status, base64 embeddings) — plus gzip
+    #   skip-capture, mid-read re-arm, and restored-body #each pins.
+    VERSION = "2.1.1"
   end
 end

metadata

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