coolhand 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3c1e767ea245f56520ee634e48cd2f12c6dc06be79b3998537fea9e9b8ea9ff
-  data.tar.gz: aad0485d474aa1e3f796f2af30083304a1ed704ede8428ddc4b0c9a4ff32678e
+  metadata.gz: 8f38b442e23ef4733417edbaa234c3459734a11f861caeb4261ea034f7a464dd
+  data.tar.gz: c3d6aee98d5eea898ff53bedba1f43497c82517ad335d330d5e6619a5035e13f
 SHA512:
-  metadata.gz: 2b497e1401c64e9eb6a6b1bbb061ecb359985a39f8dd95ce8018406d36e3c49ba061e5557299d4e6ee00498f8f8bf91ac9f3b91e56a32f5b08af599f5ef16768
-  data.tar.gz: 84d13bff930f045607270849ad02fd5c8548b15b39f2043636c868bcfe857e04fab4c0ae113fe4e5872ca299d197c83b04c2f0adce5bffe3723c4bacd5890b03
+  metadata.gz: feafe561a70cd33c6c995f1ebd20c1d93e93ca9bb092dc6214f5b52464eb23e9ac68797d2c64377a2e215ed9ca0d50fa1b4b43f91dd2b355577ca33a2c80483f
+  data.tar.gz: 749542ecea37f0d9f08840bf6e0eda16fe5aa65f4484abb1e720c3358667190137509e99f80d798e0b3292809f95efd7823e7655a8c05db1b0747ebdcf784b02

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-09-20
+
+### Added
+- **Seven more providers are monitored out of the box** ([#117](https://github.com/Coolhand-Labs/coolhand-ruby/pull/117)) — DeepSeek (`api.deepseek.com`), Mistral (`api.mistral.ai`), Perplexity (`api.perplexity.ai`) and xAI (`api.x.ai`) are captured host-wide. Cohere is captured only on its chat and embed endpoints (`/v2/chat`, `/v1/embed`, `/v2/embed`, on `api.cohere.com` and `api.cohere.ai`), TypeSafe Jev only on `api.typesafe.ai/v1/systemone`, and Ollama only on port 11434 for `/api/chat`, `/api/generate`, `/api/embed` and `/api/embeddings` (`localhost`, `127.0.0.1`, or a bare single-label host such as a Docker Compose service). No configuration required. **Migration note:** if your app already calls any of these, those calls will now start being logged to Coolhand after upgrading. To opt out, override `config.intercept_addresses` with your own list.
+- **Azure inference endpoints are monitored out of the box** ([#115](https://github.com/Coolhand-Labs/coolhand-ruby/pull/115)) — Azure OpenAI dedicated hosts (`openai.azure.com`/`.us`/`.cn`), Azure AI Services / Foundry multi-service hosts (`cognitiveservices.azure.*`, `services.ai.azure.*`, captured only on their `/openai/` and `/models/` paths), serverless/MaaS hosts (`inference.ai.azure.com`, `models.ai.azure.com`) and Azure ML managed online endpoints (`inference.ml.azure.com`/`.us`). The Azure ML entries are deliberately not path-anchored, because every managed online endpoint scores at `/score`, so non-LLM deployments there will also be captured. Remove those two entries from `intercept_addresses` if that over-captures for you. Default `exclude_api_patterns` now also skips Azure OpenAI control-plane paths (`/openai/files`, `/batches`, `/fine_tuning`, `/models`, and their `/openai/v1/` spellings). **Migration note:** anyone who set `exclude_api_patterns` explicitly keeps their own list and will not get the new Azure exclusions.
+- **`intercept_addresses` entries can pin a port and/or a path prefix** ([#117](https://github.com/Coolhand-Labs/coolhand-ruby/pull/117), [#115](https://github.com/Coolhand-Labs/coolhand-ruby/pull/115)) — `host:port`, `host/path` and `host:port/path` are all accepted. A request must match every part, and the path matches on a segment boundary (`host/openai` matches `/openai` and `/openai/x`, not `/openaiz`). Plain-host entries behave exactly as before. See [Configuration](docs/configuration.md#custom-intercept-addresses).
+
+### Changed
+- Ruby 4.0 was added to the CI matrix ([#113](https://github.com/Coolhand-Labs/coolhand-ruby/pull/113)) and then removed again before release: its job could not `bundle install` against the locked dependencies (`BUNDLED WITH 2.3.6`, the conditional `pry-byebug`/`debug` Gemfile entry and `unicode-emoji 4.1.0`). CI covers Ruby 3.1–3.4 until the lock can support 4.0.
+
+### Fixed
+- `examples/anthropic_example.rb` could not run against the pinned `anthropic` 0.4.x gem: it relied on the client reading `ANTHROPIC_API_KEY` from the environment and on object-style response access, and it targeted a retired model. It now passes `access_token:` explicitly, reads the response as a Hash, and uses `claude-haiku-4-5-20251001`. Found by running it against a live key during release validation.
+
+### Security
+- **Azure OpenAI "On Your Data" datastore credentials are now redacted from captured request bodies** ([#115](https://github.com/Coolhand-Labs/coolhand-ruby/pull/115)) — a request's `data_sources`/`dataSources` entries can carry live credentials (Azure AI Search API keys, Cosmos/Mongo connection strings, Elasticsearch encoded keys) that header and URL sanitization never looked at. `BaseInterceptor.sanitize_body` now replaces any value under those entries whose key name contains `key`, `token`, `secret`, `password`, `credential`, `connectionstring` or `signature` (separators and case ignored) with `[REDACTED]` before the log is forwarded. Message content and tool definitions outside `data_sources` are untouched.
+- **Release-time hardening from a whole-package security review:**
+  - `Coolhand.log` no longer raises when stdout is unwritable. Previously a failing `puts` inside the interceptor's `ensure` block could replace the host application's own LLM response with an `IOError`.
+  - A bad `intercept_addresses`/`exclude_api_patterns` value (e.g. a String or Symbol instead of an array of Strings) now degrades to "don't capture" instead of raising into every intercepted request.
+  - `BaseInterceptor.sanitize_url` now fails closed on an unparseable URL, dropping userinfo, query and fragment rather than returning the raw URL with credentials intact.
+  - Header redaction now also matches names containing `auth`, `passw`, `credential`, `bearer`, `jwt` or `session` (e.g. `X-Auth`, `X-Session-Id`, `X-Jwt`). **Migration note:** headers such as `x-session-id` now appear as `[REDACTED]` in Coolhand.
+  - `sanitize_body` matches the `data_sources` key case- and separator-insensitively, and also redacts `pwd`, `passw*`, `bearer` and `jwt` credential keys.
+  - Hosts with a trailing dot (`api.openai.com.`) are now matched like their dotless form.
+  - `OpenAi::WebhookValidator` rejects a bare `whsec_` secret, which decodes to an empty HMAC key and would make signatures forgeable.
+
+### Documentation
+- Clarified that Google's "Gemini Enterprise Agent Platform" is the new marketing name for Vertex AI and does not change `aiplatform.googleapis.com` or `Coolhand::Vertex` ([#118](https://github.com/Coolhand-Labs/coolhand-ruby/pull/118)).
+
 ## [0.6.0] - 2026-09-12
 
 ### Added

data/README.md

@@ -120,8 +120,8 @@ Coolhand.configure do |config|
   config.silent = Rails.env.production?
 
   # Specify which LLM endpoints to intercept (array of strings)
-  # Optional - defaults to OpenAI, Anthropic, ElevenLabs, Google Gemini, and GitHub Models
-  # config.intercept_addresses = ["api.openai.com", "api.anthropic.com", "api.cohere.ai"]
+  # Optional - defaults to every provider listed under "Supported Libraries" below
+  # config.intercept_addresses = ["api.openai.com", "api.anthropic.com", "api.cohere.com/v2/chat"]
 end
 ```
 
@@ -178,7 +178,7 @@ end
 | `enabled` | Boolean | `true` | Set to `false` to disable all patching and validation (e.g. `Rails.env.production?`) |
 | `capture` | Boolean | `true` | Whether to capture and forward intercepted requests. Set to `false` to monitor without forwarding, then use [`Coolhand.with_capture`](#selective-capture) to re-enable selectively |
 | `silent` | Boolean | `false` | Whether to suppress console output |
-| `intercept_addresses` | Array | `["api.openai.com", "api.anthropic.com"]` | Array of API hosts to monitor (matched by host, not full URL). This is a required allow-list — `[]` is ignored (a warning is logged) rather than disabling capture; use `enabled` or `capture` for that. See [Configuration](docs/configuration.md) |
+| `intercept_addresses` | Array | All [supported providers](#supported-libraries) (`DEFAULT_INTERCEPT_ADDRESSES`) | Array of API hosts to monitor (matched by host, optionally pinned to a port and/or path prefix). This is a required allow-list — `[]` is ignored (a warning is logged) rather than disabling capture; use `enabled` or `capture` for that. See [Configuration](docs/configuration.md) |
 | `intercept_path_patterns` | Array | `[":generateContent", ":streamGenerateContent"]` | Path patterns to additionally monitor on Google API hosts — see [Configuration](docs/configuration.md) |
 | `exclude_api_patterns` | Array | `["/batchPredictionJobs/"]` | Deny-list checked after `intercept_addresses`; matching paths are skipped. Unlike `intercept_addresses`, `exclude_api_patterns = []` genuinely disables exclusion. See [Configuration](docs/configuration.md) |
 | `max_captured_body_bytes` | Integer | `1_000_000` | Maximum size of a captured JSON request body — oversized bodies are replaced with a placeholder. Non-JSON bodies (e.g. file/audio uploads) are always skipped regardless of size — see [Advanced Configuration](docs/configuration.md) |
@@ -337,10 +337,18 @@ The monitor works with multiple transport layers and Ruby libraries:
 **Other providers monitored out of the box:**
 - Google Gemini (`generativelanguage.googleapis.com`)
 - Google Vertex AI (`aiplatform.googleapis.com`) — see the [Vertex AI batch result logging guide](docs/vertex.md) for async batch jobs
+- Azure OpenAI Service, Azure AI Foundry, and Azure Machine Learning managed online endpoints (dedicated hosts, multi-service Azure AI Services hosts, and serverless/MaaS deployments) — see [Configuration](docs/configuration.md) for the full list of covered hosts
 - AWS Bedrock (OpenAI-compatible endpoint)
 - Cloudflare AI Gateway
 - OpenRouter
 - OpenCode Zen (`opencode.ai`)
+- DeepSeek (`api.deepseek.com`)
+- Mistral (`api.mistral.ai`)
+- Perplexity (`api.perplexity.ai`)
+- xAI (`api.x.ai`)
+- Cohere (chat and embed endpoints only, on `api.cohere.com` and `api.cohere.ai`)
+- TypeSafe Jev / System One (`api.typesafe.ai/v1/systemone`)
+- Ollama (self-hosted, default port 11434 — chat, generate and embed endpoints) — see [Configuration](docs/configuration.md) for non-default hosts
 
 **Universal Coverage**: Since most Ruby HTTP libraries use Net::HTTP under the hood, Coolhand's single interceptor provides comprehensive monitoring without needing library-specific integrations.
 

data/docs/configuration.md

@@ -74,7 +74,13 @@ Setting `intercept_addresses` **replaces** the default list entirely, so include
 
 The default list can be found in `Coolhand::Configuration::DEFAULT_INTERCEPT_ADDRESSES`.
 
-Each entry is matched against the request's parsed host — an exact match, or a dot-boundary suffix match (`my-llm-proxy.internal` also matches `eu.my-llm-proxy.internal`) — case-insensitively. A single `*` in an entry matches exactly one host label, e.g. `bedrock-runtime.*.amazonaws.com`. Entries are never matched against the full URL, so query strings or paths that merely mention a host can't trigger a false match.
+Each entry is matched against the request's parsed host (optionally with a port and path prefix, see below) — an exact match, or a dot-boundary suffix match (`my-llm-proxy.internal` also matches `eu.my-llm-proxy.internal`) — case-insensitively. A single `*` in an entry matches exactly one host label, e.g. `bedrock-runtime.*.amazonaws.com`. Entries are never matched against the full URL, so query strings that merely mention a host can't trigger a false match.
+
+An entry can also pin a port (`host:port`) and/or a path (`host/path`, or `host:port/path`), and then a request must match all of them. Cohere, TypeSafe and Ollama are defaulted this way: `api.cohere.com/v2/chat`, `api.typesafe.ai/v1/systemone`, and `*:11434/api/chat` (plus `/api/generate`, `/api/embed`, `/api/embeddings`, also for `127.0.0.1`). Ollama has no fixed host, so its defaults require Ollama's default port *and* an Ollama path — an app's own unrelated `/api/chat` on another host or port is not captured. To capture an Ollama server on a dotted host or IP, or a non-default port, add entries such as `192.168.1.5:11434/api/chat` or `ollama.internal:8080/api/chat`. An IPv6 loopback server (`[::1]:11434`) is already covered by the defaults.
+
+Path-anchoring is also how the Azure defaults work: multi-service hosts like `cognitiveservices.azure.com/openai/` (Azure AI Services, where Speech, Vision, Language and Content Safety share a domain with LLM inference) only match paths under the given prefix, after the host itself has matched.
+
+**Note on Azure ML managed online endpoints:** `inference.ml.azure.com` and `inference.ml.azure.us` are intentionally captured *without* a path anchor. Every Azure ML managed online endpoint scores at `/score` regardless of what model sits behind it, so there's no path that distinguishes an LLM deployment from a tabular or vision one — this gem chooses to capture broadly rather than silently miss LLM deployments. If that over-captures for your setup, override `intercept_addresses` to a custom list omitting these two entries.
 
 A small number of Google API endpoints use a colon-suffixed path (e.g. `.../gemini-pro:generateContent`) with no host of their own. Those live in the separate `intercept_path_patterns` setting (default: `Coolhand::Configuration::DEFAULT_INTERCEPT_PATH_PATTERNS`) and, unlike `intercept_addresses`, are only checked against the path of requests whose host is already `googleapis.com` or a subdomain of it — and only when `intercept_addresses` still includes at least one `googleapis.com` host. If you override `intercept_addresses` to a list with no Google hosts, `intercept_path_patterns` has no effect and Google API traffic is not captured at all.
 
@@ -82,7 +88,7 @@ A small number of Google API endpoints use a colon-suffixed path (e.g. `.../gemi
 
 ## Excluding API Patterns
 
-`config.exclude_api_patterns` is a deny-list checked *after* `intercept_addresses` allows a request through — a match against the request's path is skipped and never forwarded as an `llm_request_log`. It defaults to `["/batchPredictionJobs/"]`, to suppress Vertex AI batch job management noise.
+`config.exclude_api_patterns` is a deny-list checked *after* `intercept_addresses` allows a request through — a match against the request's path is skipped and never forwarded as an `llm_request_log`. It defaults to a small built-in list (see `Coolhand::Configuration::DEFAULT_EXCLUDE_API_PATTERNS`) that suppresses Vertex AI batch job management noise (`/batchPredictionJobs/`) and Azure OpenAI control-plane paths (file, batch, and fine-tuning management under `/openai/` and `/openai/v1/`) that aren't inference traffic.
 
 ```ruby
 Coolhand.configure do |config|

data/docs/vertex.md

@@ -6,6 +6,8 @@ For monitoring regular (non-batch) Vertex AI calls, no extra setup is required b
 
 Requires Rails — `Coolhand::Vertex::BatchResultProcessor` logs via `Rails.logger` internally. `config.capture = false` and `Coolhand.without_capture` do not suppress these logs: unlike the passive Net::HTTP interceptor, calling this processor is an explicit, deliberate act, so it always sends.
 
+> **Note:** As of May 2026, Google markets this product as "Gemini Enterprise Agent Platform" rather than "Vertex AI." The API endpoint (`aiplatform.googleapis.com`) and Ruby SDK are unchanged — it's a console/marketing rename, not an SDK rename — so `Coolhand::Vertex` naming stays accurate here. It's also still a distinct integration from the separate Gemini Developer API (`generativelanguage.googleapis.com`), which Coolhand intercepts independently.
+
 ## Usage
 
 ```ruby

data/lib/coolhand/base_interceptor.rb

@@ -11,7 +11,7 @@ module Coolhand
     # (cookie, set-cookie), and future/unknown providers using a
     # similarly-named header. Shared with LoggerService so the two logging
     # paths (interceptor + webhook forwarding) stay consistent.
-    SENSITIVE_HEADER_PATTERN = /key|token|secret|signature|authorization|cookie/i
+    SENSITIVE_HEADER_PATTERN = /key|token|secret|signature|auth|passw|credential|bearer|jwt|session|cookie/i
 
     def sanitize_headers(headers)
       return {} if headers.nil?
@@ -110,7 +110,42 @@ module Coolhand
 
       modified ? uri.to_s : url
     rescue URI::InvalidURIError
-      url
+      # Fail closed: an unparseable URL can't be checked param-by-param, so drop everything
+      # that could carry a credential (userinfo, query, fragment) rather than pass it through.
+      url.to_s.sub(%r{//[^/?#]*@}, "//REDACTED@").split(/[?#]/, 2).first
+    end
+
+    # Key names inside an Azure OpenAI "On Your Data" data_sources/dataSources entry that carry
+    # live datastore credentials in the request body, where header/query-param sanitization never
+    # looks. Matched against a separator-stripped, lowercased key name so both `connection_string`
+    # and `connectionString` (Cosmos/Mongo, embeds `AccountKey=...`) and `encoded_api_key`
+    # (Elasticsearch) are caught — not just exact or snake_case-only names.
+    SENSITIVE_BODY_KEY_PATTERN = /key|token|secret|passw|pwd|credential|bearer|jwt|connectionstring|signature/i
+
+    def sanitize_body(body)
+      return body unless body.is_a?(Hash)
+
+      sanitized = body.dup
+      sanitized.each_key do |key|
+        next unless key.to_s.delete("_-").casecmp?("datasources")
+
+        sanitized[key] = redact_sensitive_body_values(sanitized[key])
+      end
+      sanitized
+    end
+
+    def redact_sensitive_body_values(node)
+      case node
+      when Hash
+        node.each_with_object({}) do |(k, v), acc|
+          normalized = k.to_s.gsub(/[_\-\s]/, "").downcase
+          acc[k] = normalized.match?(SENSITIVE_BODY_KEY_PATTERN) ? "[REDACTED]" : redact_sensitive_body_values(v)
+        end
+      when Array
+        node.map { |v| redact_sensitive_body_values(v) }
+      else
+        node
+      end
     end
 
     def send_complete_request_log(request_id:, method:, url:, request_headers:, request_body:, response_headers:,
@@ -121,7 +156,7 @@ module Coolhand
         method: method.to_s.downcase,
         url: sanitize_url(url),
         headers: sanitize_headers(request_headers),
-        request_body: request_body,
+        request_body: sanitize_body(request_body),
         response_headers: sanitize_headers(response_headers),
         response_body: response_body,
         status_code: status_code,

data/lib/coolhand/default_exclude_api_patterns.yml

@@ -8,3 +8,14 @@
 # Users can disable:           c.exclude_api_patterns = []
 
 - "/batchPredictionJobs/"
+# Azure OpenAI control-plane paths (not inference) — both spellings are needed
+# since substring matching is contiguous: "/openai/files" does not match
+# "/openai/v1/files".
+- "/openai/files"
+- "/openai/batches"
+- "/openai/fine_tuning"
+- "/openai/models"
+- "/openai/v1/files"
+- "/openai/v1/batches"
+- "/openai/v1/fine_tuning"
+- "/openai/v1/models"

data/lib/coolhand/default_intercept_addresses.yml

@@ -4,6 +4,10 @@
 # should be captured and forwarded as an llm_request_log. A single "*" in an
 # entry matches exactly one host label — e.g. "bedrock-runtime.*.amazonaws.com"
 # matches "bedrock-runtime.us-east-1.amazonaws.com" but nothing else.
+# An entry may also pin a port and/or a path prefix: "host:port", "host/path",
+# or "host:port/path" (the path match is on a segment boundary) — useful for
+# multi-service hosts where unrelated APIs (e.g. Azure Speech, Vision, Language)
+# share a domain with the LLM inference path.
 #
 # Users can extend defaults:   c.intercept_addresses << "my.custom.api.com"
 # Users can override entirely: c.intercept_addresses = ["only.this.com"]
@@ -20,5 +24,55 @@
 - "aiplatform.googleapis.com"
 - "gateway.ai.cloudflare.com"
 - "bedrock-runtime.*.amazonaws.com"
+- "api.deepseek.com"
+- "api.mistral.ai"
+- "api.perplexity.ai"
+- "api.x.ai"
+# Cohere is path-scoped, never host-wide: the server only ingests v2 chat and
+# v1/v2 embed, and its other endpoints (v1 chat, rerank, tokenize, classify...)
+# have different envelopes that would be recorded as empty "successes".
+- "api.cohere.com/v2/chat"
+- "api.cohere.com/v1/embed"
+- "api.cohere.com/v2/embed"
+- "api.cohere.ai/v2/chat"
+- "api.cohere.ai/v1/embed"
+- "api.cohere.ai/v2/embed"
+# TypeSafe Jev (a "System One" model, not an LLM) — only /v1/systemone is ingested.
+- "api.typesafe.ai/v1/systemone"
+# Ollama (self-hosted) has no fixed host, so an entry must pin BOTH the default
+# port (11434) and the path — a bare "/api/chat" would capture any app's own
+# unrelated chat endpoint. "*" matches one host label (localhost, an "ollama"
+# compose service, a bare hostname); a LAN IP or dotted host needs its own
+# entry, e.g. "192.168.1.5:11434/api/chat".
+- "*:11434/api/chat"
+- "*:11434/api/generate"
+- "*:11434/api/embed"
+- "*:11434/api/embeddings"
+- "127.0.0.1:11434/api/chat"
+- "127.0.0.1:11434/api/generate"
+- "127.0.0.1:11434/api/embed"
+- "127.0.0.1:11434/api/embeddings"
 - "openrouter.ai"
 - "opencode.ai"
+# Azure OpenAI dedicated hosts (commercial, US Gov, China/21Vianet)
+- "openai.azure.com"
+- "openai.azure.us"
+- "openai.azure.cn"
+# Azure AI Services / Foundry multi-service hosts — path-anchored so Speech,
+# Vision, Language and Content Safety on the same host are NOT captured
+- "cognitiveservices.azure.com/openai/"
+- "cognitiveservices.azure.com/models/"
+- "cognitiveservices.azure.us/openai/"
+- "cognitiveservices.azure.us/models/"
+- "cognitiveservices.azure.cn/openai/"
+- "cognitiveservices.azure.cn/models/"
+- "services.ai.azure.com/openai/"
+- "services.ai.azure.com/models/"
+- "services.ai.azure.us/openai/"
+- "services.ai.azure.us/models/"
+# Serverless / MaaS + Azure ML managed online endpoints. inference.ml.azure.*
+# is deliberately unanchored — see docs/configuration.md for why.
+- "inference.ai.azure.com"
+- "models.ai.azure.com"
+- "inference.ml.azure.com"
+- "inference.ml.azure.us"

data/lib/coolhand/net_http_interceptor.rb

@@ -93,9 +93,8 @@ module Coolhand
       active = (Thread.current[:coolhand_active_requests] ||= {}.compare_by_identity)
       return super if active.key?(self)
 
-      url = build_url_for_request(self, req)
-      return super unless intercept?(url)
-      return super unless should_capture?
+      url = capturable_url(req)
+      return super unless url
 
       # Capture body before setting the guard — if this raises we skip logging cleanly
       # and the guard is never set, so there is no leak. A failure here (e.g. an
@@ -226,17 +225,28 @@ module Coolhand
 
       return false if excluded_by_pattern?(uri)
 
-      host = uri.host.downcase
+      host = uri.host.downcase.chomp(".")
+      path = uri.path.to_s
       addresses = Coolhand.configuration.intercept_addresses
-      return true if addresses.any? { |a| host_matches?(host, a) }
+      authorities = [host, "#{host}:#{uri.port}"]
+      return true if addresses.any? { |a| authorities.any? { |authority| address_matches?(authority, path, a) } }
 
       return false unless google_api_host_configured?(addresses)
       return false unless host == "googleapis.com" || host.end_with?(".googleapis.com")
 
-      path = uri.path.to_s
       Coolhand.configuration.intercept_path_patterns.any? { |p| path.include?(p) }
     end
 
+    # The capture decision runs before the host's real request, so a bad config value (e.g. a
+    # non-array exclude_api_patterns) must degrade to "don't capture", never raise into the host.
+    def capturable_url(req)
+      url = build_url_for_request(self, req)
+      url if intercept?(url) && should_capture?
+    rescue StandardError => e
+      Coolhand.log "⚠️ Skipping capture, could not evaluate intercept rules: #{e.class}"
+      nil
+    end
+
     def excluded_by_pattern?(uri)
       patterns = Coolhand.configuration.exclude_api_patterns
       return false if patterns.nil? || patterns.empty?
@@ -259,6 +269,26 @@ module Coolhand
       end
     end
 
+    # An intercept_addresses entry may optionally pin a port ("host:port") and/or anchor to a
+    # path prefix by embedding a "/" — e.g. "api.cohere.com/v2/chat" only matches requests to
+    # that host whose path starts with "/v2/chat", and "cognitiveservices.azure.com/openai/" only
+    # matches that multi-service Azure host's OpenAI paths, so unrelated endpoints on a shared
+    # host aren't swept in alongside the ones we mean to capture.
+    # The match is on a path *segment* boundary (trailing "/" on the pattern is optional and
+    # stripped before comparing), so "host.com/openai" matches "/openai" and "/openai/x" but not
+    # a same-prefix-but-different-segment path like "/openaiz".
+    def address_matches?(host, path, pattern)
+      host_pattern, sep, path_pattern = pattern.to_s.partition("/")
+      return host_matches?(host, host_pattern) if sep.empty?
+      return false unless host_matches?(host, host_pattern)
+
+      path_pattern = path_pattern.delete_suffix("/")
+      return true if path_pattern.empty?
+
+      prefix = "/#{path_pattern}"
+      path == prefix || path.start_with?("#{prefix}/")
+    end
+
     # Host-boundary match: exact, or a dot-delimited suffix (case-insensitive).
     # A single "*" in `pattern` matches exactly one host label, e.g.
     # "bedrock-runtime.*.amazonaws.com" matches "bedrock-runtime.us-east-1.amazonaws.com".

data/lib/coolhand/open_ai/webhook_validator.rb

@@ -98,7 +98,8 @@ module Coolhand
         signed_payload = "#{webhook_id}.#{webhook_timestamp}.#{@payload}"
         expected_signature = calculate_expected_signature(secret_bytes, signed_payload)
 
-        signature_valid = webhook_signature.start_with?("v1,") &&
+        # An empty key (a bare "whsec_" secret) makes the HMAC forgeable by anyone, so never accept it.
+        signature_valid = !secret_bytes.empty? && webhook_signature.start_with?("v1,") &&
                           secure_compare(webhook_signature[3..], expected_signature)
 
         unless signature_valid

data/lib/coolhand/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coolhand
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/coolhand.rb

@@ -91,6 +91,10 @@ module Coolhand
       return if configuration.silent
 
       puts "COOLHAND: #{message}"
+    rescue StandardError
+      # Logging must never raise into the host app (e.g. a closed stdout) — least of all from
+      # the interceptor's ensure block, where it would replace the host's own response.
+      nil
     end
 
     # Creates a new FeedbackService instance

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coolhand
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Michael Carroll
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64