riffer 0.35.0 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acfc9a0c002c97b79d515172d71aa419359e27fac0a3809934c30057931e66ef
-  data.tar.gz: 322aaebffb66c41824fdd3a3c43d08ae6bb806f8e2e06ca5ee1834648704e1d5
+  metadata.gz: 491260200757bf1d17b920f099012d771328fd333d46bb325f53dca863bcf204
+  data.tar.gz: 072ffcdf47b2aa115a3c7743cb77d4f238d18b926f0a53eb6b45a28148b8b2be
 SHA512:
-  metadata.gz: ba3554a4a135ae43f5d5a2d65928275e4acfcc27c03609f2578d5304e8825c3f42f05b7229fe5881fdc7c663372ef6ca3591af02b2719167bc7711fc7754e7e6
-  data.tar.gz: 49c2b41f0cb606ec9e86b72777d55b3b3222220d879b5e05ed211a07094d9561c7e1c054ce2689d3b81b6ff872d981f6e1f24306b916cf12a697f7df23f91a69
+  metadata.gz: 97bf5aeed05fe9b591ae5a2bcf7c59d6990a46de1695fa4ff929823ead08b23372f35c4efb389a7e2f769a2a15dbad4dcb35bb1421e57c1fe5291216390b176c
+  data.tar.gz: 421d381a7d8c0a1be0c017a2c347096fa452d48d512706c474e82b5d90097e245d9f7680ed6745c10aac31502cdfe47efc56ae885dbd9e4b52b3b7e2803b7c10

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.35.0"
+  ".": "0.36.0"
 }

data/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.36.0](https://github.com/janeapp/riffer/compare/riffer/v0.35.0...riffer/v0.36.0) (2026-07-03)
+
+
+### ⚠ BREAKING CHANGES
+
+* config.metrics, the Riffer::Metrics module, and Riffer::Metrics::Otel are removed. Hosts wiring a metrics backend must drop that configuration.
+
+### Features
+
+* remove the metrics primitive ([#347](https://github.com/janeapp/riffer/issues/347)) ([70a838e](https://github.com/janeapp/riffer/commit/70a838e9d49da12f89886c6e6f7bca35f427f77c))
+
 ## [0.35.0](https://github.com/janeapp/riffer/compare/riffer/v0.34.0...riffer/v0.35.0) (2026-06-25)
 
 

data/README.md

@@ -63,7 +63,6 @@ For comprehensive documentation, see the [docs](docs/) directory:
 - [MCP](docs/14_MCP.md) - Integrating third-party MCP servers
 - [Serialization](docs/15_SERIALIZATION.md) - Persisting and transferring agent definitions
 - [Tracing](docs/16_TRACING.md) - OpenTelemetry span contract and host wiring
-- [Metrics](docs/17_METRICS.md) - OpenTelemetry metric contract and host wiring
 - [Providers](docs/providers/01_PROVIDERS.md) - LLM provider adapters
 
 ### API Reference

data/docs/01_OVERVIEW.md

@@ -132,7 +132,6 @@ Response
 - [Tools](06_TOOLS.md) - Creating tools
 - [Configuration](10_CONFIGURATION.md) - Global configuration
 - [Tracing](16_TRACING.md) - OpenTelemetry span contract and host wiring
-- [Metrics](17_METRICS.md) - OpenTelemetry metric contract and host wiring
 - [Evals](11_EVALS.md) - Evaluating agent quality
 - [Guardrails](12_GUARDRAILS.md) - Input/output validation
 - [Skills](13_SKILLS.md) - Packaged agent capabilities

data/docs/03_AGENTS.md

@@ -333,7 +333,7 @@ Keys and values may be `String` or `Symbol`; both are stringified, and entries w
 Tags propagate to **two** places:
 
 1. The provider's native per-request metadata field (see the mapping below).
-2. Observability — stamped as `riffer.tag.<key>` on **every** span and metric the call emits (`invoke_agent`, `chat`, `execute_tool`, `execute_guardrail` spans, and the duration/token-usage/cost metrics). See [Tracing](16_TRACING.md) and [Metrics](17_METRICS.md).
+2. Observability — stamped as `riffer.tag.<key>` on **every** span the call emits (`invoke_agent`, `chat`, `execute_tool`, `execute_guardrail`). See [Tracing](16_TRACING.md).
 
 ### Reserved key: `user_id`
 
@@ -349,18 +349,14 @@ Tags propagate to **two** places:
 | Anthropic             | `metadata.user_id` **only**   | The only tag forwarded                  |
 | Gemini                | _(none — observability only)_ | Tag only; no request field              |
 
-**Anthropic silently drops non-`user_id` tags.** The Messages API has no free-form request-metadata field — only `metadata.user_id`. So for Anthropic, `user_id` is forwarded as `metadata: {user_id: …}` and **every other tag is dropped from the request** (it still appears on spans and metrics). This is intentional.
+**Anthropic silently drops non-`user_id` tags.** The Messages API has no free-form request-metadata field — only `metadata.user_id`. So for Anthropic, `user_id` is forwarded as `metadata: {user_id: …}` and **every other tag is dropped from the request** (it still appears on spans). This is intentional.
 
-**Gemini is observability-only.** Riffer's Gemini adapter targets the Gemini Developer API (`generativelanguage.googleapis.com`), whose `generateContent` request has **no** `labels` field — sending unknown fields is rejected. So tags are **not** added to the Gemini request; they propagate to spans and metrics only. Native request labels (`labels`, lowercase `[a-z0-9_-]`, ≤63 chars each) are a Vertex AI feature and would arrive with a future Vertex adapter.
+**Gemini is observability-only.** Riffer's Gemini adapter targets the Gemini Developer API (`generativelanguage.googleapis.com`), whose `generateContent` request has **no** `labels` field — sending unknown fields is rejected. So tags are **not** added to the Gemini request; they propagate to spans only. Native request labels (`labels`, lowercase `[a-z0-9_-]`, ≤63 chars each) are a Vertex AI feature and would arrive with a future Vertex adapter.
 
 ### Provider limits (not enforced)
 
 Riffer does not validate tag count, key/value length, or charset — it forwards what you give it and lets the provider reject anything out of bounds. Known limits: Bedrock `requestMetadata` ≤16 entries, key/value ≤256 chars; OpenAI / OpenRouter `metadata` ≤16 pairs (OpenRouter: 64-char keys, 512-char values).
 
-### Metric cardinality
-
-Tags are promoted onto metric dimensions verbatim — there is no allow-list. High-cardinality values (e.g. a unique `user_id` per request) will create a correspondingly large number of metric series in your backend. Keep metric-bound tags low-cardinality.
-
 ## Expand Your Agent
 
 | Goal                          | Feature           | Guide                                                                |

data/docs/10_CONFIGURATION.md

@@ -119,23 +119,6 @@ end
 | `capture_messages` | Opt-in capture of full message content on LLM-call spans (`gen_ai.input.messages`, `gen_ai.output.messages`, `gen_ai.system_instructions`) as GenAI-semconv JSON. Defaults to `false` — message content routinely carries sensitive data. File attachments serialize as metadata-only stubs (media type and name, never bytes), and riffer applies no size limit of its own — cap oversized attributes with the OTEL SDK attribute length limits.                                                                                                                  |
 | `backend`          | The backend riffer routes spans through. Assign `Riffer::Tracing::Otel.build` (pass `provider:` to override the global tracer provider — e.g. an in-memory provider in tests), or any object satisfying the duck-typed contract (`in_span` / `current_context` / `with_context`) to route into a non-OTEL system (e.g. Datadog APM). Defaults to `nil` — a no-op. Raises `Riffer::ArgumentError` unless the value is `nil` or responds to `in_span`. See [Tracing → Routing to a non-OpenTelemetry backend](16_TRACING.md#routing-to-a-non-opentelemetry-backend). |
 
-### Metrics
-
-Metrics-related global configuration lives under `config.metrics`, **independent** of `config.tracing` — each has its own kill switch and its own backend, so you can run one signal without the other. Riffer records measurements only through the backend you assign to `config.metrics.backend` — there is **no auto-detection**. OpenTelemetry is a built-in backend you opt into explicitly with `Riffer::Metrics::Otel.build`; with no backend set every measurement is a silent no-op, and riffer carries no OTEL gem dependency either way. The metrics API and SDK are separate, still-experimental (pre-1.0) gems from the traces API.
-
-```ruby
-Riffer.configure do |config|
-  config.metrics.enabled = ENV.fetch("RIFFER_METRICS_ENABLED", "true")
-  # Opt into OpenTelemetry (uses the global meter provider):
-  config.metrics.backend = Riffer::Metrics::Otel.build
-end
-```
-
-| Option    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `enabled` | The kill switch, consulted on every measurement — flipping it at runtime takes effect immediately, short-circuiting to a no-op ahead of the backend. Accepts booleans or `'true'`/`'false'`/`'1'`/`'0'`. Defaults to `true`.                                                                                                                                                                                                                                                                                                 |
-| `backend` | The backend riffer routes measurements through. Assign `Riffer::Metrics::Otel.build` (pass `provider:` to override the global meter provider — e.g. an in-memory provider in tests), or any object responding to `record_histogram` to route into a non-OTEL system (e.g. DogStatsD). Defaults to `nil` — a no-op. Raises `Riffer::ArgumentError` unless the value is `nil` or responds to `record_histogram`. See [Metrics → Routing to a non-OpenTelemetry backend](17_METRICS.md#routing-to-a-non-opentelemetry-backend). |
-
 ### Pricing
 
 Configure per-model token prices and riffer computes the cost of each LLM call onto its [`TokenUsage`](08_MESSAGES.md#token-usage-semantics). Riffer ships **no** price table — so an unconfigured model simply carries no cost (`token_usage.cost` is `nil`).

data/lib/riffer/agent/run.rb

@@ -37,33 +37,22 @@ module Riffer::Agent::Run
 
   # Both +generate+ and +stream+ funnel here, so this is the single place raw
   # +tags+ are normalized. The clean <tt>String => String</tt> map is then
-  # threaded to every span/metric builder in the run as +riffer.tag.*+ and to
-  # each provider call (via +merged_model_options+) for native request-metadata
+  # threaded to every span builder in the run as +riffer.tag.*+ and to each
+  # provider call (via +merged_model_options+) for native request-metadata
   # mapping.
   #--
   #: (Riffer::Agent, ?tags: Hash[(String | Symbol), untyped]?, ?stream_yielder: Enumerator::Yielder?) -> Riffer::Agent::Response
   def run_loop(agent, tags: {}, stream_yielder: nil)
     tags = normalize_tags(tags)
-    start = Riffer::Metrics.monotonic_now
-    error_type = nil #: String?
-    begin
-      Riffer::Tracing.in_span("invoke_agent #{agent.class.identifier}", attributes: run_span_attributes(agent, tags), kind: :internal) do |span|
-        response = execute_run(agent, stream_yielder, tags)
-        record_run_outcome(span, response)
-        response
-      rescue => error
-        # The backend records the exception and error status on the re-raise;
-        # error.type is the one semconv attribute it doesn't set.
-        span.set_attribute("error.type", error.class.name)
-        raise
-      end
+    Riffer::Tracing.in_span("invoke_agent #{agent.class.identifier}", attributes: run_span_attributes(agent, tags), kind: :internal) do |span|
+      response = execute_run(agent, stream_yielder, tags)
+      record_run_outcome(span, response)
+      response
     rescue => error
-      # The inner rescue tags the span; capture error.type here too, at method
-      # scope, where the ensure can read it onto the metric.
-      error_type = error.class.name #: String?
+      # The backend records the exception and error status on the re-raise;
+      # error.type is the one semconv attribute it doesn't set.
+      span.set_attribute("error.type", error.class.name)
       raise
-    ensure
-      Riffer::Metrics::Instruments::OPERATION_DURATION.record(Riffer::Metrics.monotonic_now - start, attributes: run_metric_attributes(agent, error_type, tags))
     end
   end
 
@@ -295,8 +284,8 @@ module Riffer::Agent::Run
 
   # +tags+ rides in the options hash as a curated key the providers extract for
   # native request-metadata mapping (alongside +:structured_output+); it never
-  # reaches an SDK call verbatim. Span/metric tagging is threaded separately to
-  # each builder.
+  # reaches an SDK call verbatim. Span tagging is threaded separately to each
+  # builder.
   #--
   #: (Riffer::Agent, ?Hash[String, String]) -> Hash[Symbol, untyped]
   def merged_model_options(agent, tags = {})
@@ -352,19 +341,6 @@ module Riffer::Agent::Run
     }.merge(tag_attributes(tags))
   end
 
-  #--
-  #: (Riffer::Agent, String?, ?Hash[String, String]) -> Hash[String, untyped]
-  def run_metric_attributes(agent, error_type, tags = {})
-    attributes = {
-      "gen_ai.operation.name" => "invoke_agent",
-      "gen_ai.provider.name" => agent.provider.class.semconv_provider_name,
-      "gen_ai.request.model" => agent.model_name,
-      "gen_ai.agent.name" => agent.class.identifier
-    } #: Hash[String, untyped]
-    attributes["error.type"] = error_type if error_type
-    attributes.merge(tag_attributes(tags))
-  end
-
   #--
   #: (Hash[(String | Symbol), untyped]?) -> Hash[String, String]
   def normalize_tags(tags)

data/lib/riffer/agent.rb

@@ -290,7 +290,7 @@ class Riffer::Agent
   #
   # +tags:+ is an optional flat hash of attribution tags applied to this single
   # call: they propagate to the provider's native request-metadata field, and
-  # are stamped as +riffer.tag.*+ on every span and metric the call emits. See
+  # are stamped as +riffer.tag.*+ on every span the call emits. See
   # +docs/03_AGENTS.md+ for the per-provider mapping. The reserved key
   # +user_id+ also maps to the provider's native user identifier where one
   # exists.

data/lib/riffer/config.rb

@@ -106,47 +106,6 @@ class Riffer::Config
     end
   end
 
-  # Metrics-related global configuration, independent of +config.tracing+ so a
-  # host can run one signal without the other.
-  class Metrics
-    # Whether riffer records OTEL metric instruments; defaults to +true+, a
-    # no-op until a host wires an OTEL metrics SDK.
-    attr_reader :enabled #: bool
-
-    # The backend riffer routes measurements through; defaults to +nil+, a no-op.
-    # Riffer auto-detects no backend; assigning one is opt-in.
-    attr_reader :backend #: untyped
-
-    #--
-    #: () -> void
-    def initialize
-      @enabled = true
-      @backend = nil
-    end
-
-    # Sets the enabled flag, coercing boolean-ish values so an env-var
-    # +"false"+ (truthy in Ruby) doesn't silently keep metrics on. Raises
-    # Riffer::ArgumentError on an unrecognized value.
-    #--
-    #: (untyped) -> void
-    def enabled=(value)
-      @enabled = Riffer::Helpers::Boolean.coerce(value, attribute: "enabled")
-    end
-
-    # Sets the metrics backend riffer routes measurements through. Raises
-    # Riffer::ArgumentError unless the value is +nil+ or responds to
-    # +record_histogram+.
-    #--
-    #: (untyped) -> void
-    def backend=(value)
-      unless value.nil? || value.respond_to?(:record_histogram)
-        raise Riffer::ArgumentError, "metrics backend must respond to #record_histogram"
-      end
-      @backend = value
-      Riffer::Metrics.reset!
-    end
-  end
-
   # Consumer-configured token pricing, keyed by +provider/model+ id. Riffer
   # ships no price table, so an unconfigured model carries no cost.
   class Pricing
@@ -306,9 +265,6 @@ class Riffer::Config
   # Tracing-related global configuration.
   attr_reader :tracing #: Riffer::Config::Tracing
 
-  # Metrics-related global configuration.
-  attr_reader :metrics #: Riffer::Config::Metrics
-
   # Consumer-configured per-model token pricing.
   attr_reader :pricing #: Riffer::Config::Pricing
 
@@ -357,7 +313,6 @@ class Riffer::Config
     @tool_runtime = Riffer::Tools::Runtime::Inline.new
     @skills = Skills.new
     @tracing = Tracing.new
-    @metrics = Metrics.new
     @pricing = Pricing.new
     @message_id_strategy = :none
     @experimental_history_healing = false

data/lib/riffer/guardrails/runner.rb

@@ -85,32 +85,15 @@ class Riffer::Guardrails::Runner
   #--
   #: (Riffer::Guardrail, untyped, messages: Array[Riffer::Messages::Base]?) -> Riffer::Guardrails::Result
   def execute_guardrail(guardrail, data, messages:)
-    instrument_guardrail(guardrail) do
-      Riffer::Tracing.in_span("execute_guardrail #{guardrail.name}", attributes: guardrail_span_attributes(guardrail), kind: :internal) do |span|
-        result = run_guardrail_phase(guardrail, data, messages: messages)
-        record_guardrail_outcome(span, result)
-        result
-      rescue => error
-        # The backend records the exception and error status on the re-raise;
-        # error.type is the one semconv attribute it doesn't set.
-        span.set_attribute("error.type", error.class.name)
-        raise
-      end
-    end
-  end
-
-  #--
-  #: (Riffer::Guardrail) { () -> Riffer::Guardrails::Result } -> Riffer::Guardrails::Result
-  def instrument_guardrail(guardrail)
-    start = Riffer::Metrics.monotonic_now
-    error_type = nil #: String?
-    begin
-      yield
+    Riffer::Tracing.in_span("execute_guardrail #{guardrail.name}", attributes: guardrail_span_attributes(guardrail), kind: :internal) do |span|
+      result = run_guardrail_phase(guardrail, data, messages: messages)
+      record_guardrail_outcome(span, result)
+      result
     rescue => error
-      error_type = error.class.name #: String?
+      # The backend records the exception and error status on the re-raise;
+      # error.type is the one semconv attribute it doesn't set.
+      span.set_attribute("error.type", error.class.name)
       raise
-    ensure
-      Riffer::Metrics::Instruments::GUARDRAIL_DURATION.record(Riffer::Metrics.monotonic_now - start, attributes: guardrail_metric_attributes(guardrail, error_type))
     end
   end
 
@@ -136,14 +119,6 @@ class Riffer::Guardrails::Runner
     }.merge(tags.transform_keys { |key| "riffer.tag.#{key}" })
   end
 
-  #--
-  #: (Riffer::Guardrail, String?) -> Hash[String, untyped]
-  def guardrail_metric_attributes(guardrail, error_type)
-    attributes = guardrail_span_attributes(guardrail)
-    attributes["error.type"] = error_type if error_type
-    attributes
-  end
-
   # A block is a handled outcome, so its span status stays unset — an error
   # span status is reserved for a raised exception.
   #--

data/lib/riffer/providers/anthropic.rb

@@ -63,7 +63,7 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
 
     # Anthropic's only request-metadata field is metadata.user_id (opaque, no
     # PII). It carries the reserved user_id tag; all other tags are dropped
-    # here and survive only on spans/metrics.
+    # here and survive only on spans.
     user_id = tags["user_id"]
     params[:metadata] = {user_id: user_id} if user_id
 

data/lib/riffer/providers/base.rb

@@ -46,7 +46,6 @@ class Riffer::Providers::Base
     validate_normalized_messages!(messages)
     messages = merge_consecutive_messages(messages)
     params = build_request_params(messages, model, options)
-    tags = options[:tags] || {}
 
     in_chat_span(model, messages, options) do |span|
       response = execute_generate(params)
@@ -58,8 +57,6 @@ class Riffer::Providers::Base
       structured_output = parse_structured_output(content) if options[:structured_output] && tool_calls.empty?
 
       Riffer::Tracing.record_usage(span, token_usage)
-      record_token_usage_metric(model, token_usage, tags)
-      record_cost_metric(model, token_usage, tags)
       record_finish_reason(span, finish_reason&.reason, finish_reason&.raw)
       capture_output(span, content: content, tool_calls: tool_calls, finish_reason: finish_reason&.reason)
 
@@ -85,26 +82,17 @@ class Riffer::Providers::Base
     validate_normalized_messages!(messages)
     messages = merge_consecutive_messages(messages)
     params = build_request_params(messages, model, options)
-    tags = options[:tags] || {}
 
     # The enumerator body runs in its own fiber, where the fiber-local OTEL
     # context is empty — capture here so the chat span parents to the caller's
-    # trace. tags are an ordinary local captured in the closure, so they reach
-    # the span/metric builders without re-propagation.
+    # trace.
     trace_context = Riffer::Tracing.current_context
     Enumerator.new do |yielder|
       Riffer::Tracing.with_context(trace_context) do
         in_chat_span(model, messages, options) do |span|
-          # The recorder feeds both the span and the token-usage metric, so build
-          # it whenever either is live — metrics fire even with tracing off.
-          observe = span.recording? || Riffer::Metrics.recording?
-          sink = observe ? Riffer::Tracing::StreamRecorder.new(yielder) : yielder
+          sink = span.recording? ? Riffer::Tracing::StreamRecorder.new(yielder) : yielder
           execute_stream(params, sink)
-          if sink.is_a?(Riffer::Tracing::StreamRecorder)
-            record_stream_outcome(span, sink)
-            record_token_usage_metric(model, sink.token_usage, tags)
-            record_cost_metric(model, sink.token_usage, tags)
-          end
+          record_stream_outcome(span, sink) if sink.is_a?(Riffer::Tracing::StreamRecorder)
         end
       end
     end
@@ -225,26 +213,14 @@ class Riffer::Providers::Base
   #--
   #: [R] (String?, Array[Riffer::Messages::Base], Hash[Symbol, untyped]) { (Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span) -> R } -> R
   def in_chat_span(model, messages, options)
-    start = Riffer::Metrics.monotonic_now
-    error_type = nil #: String?
-    tags = options[:tags] || {} #: Hash[String, String]
-    begin
-      Riffer::Tracing.in_span(model ? "chat #{model}" : "chat", attributes: chat_span_attributes(model, options), kind: :client) do |span|
-        capture_input(span, messages)
-        yield span
-      rescue => error
-        # The backend records the exception and error status on the re-raise;
-        # error.type is the one semconv attribute it doesn't set.
-        span.set_attribute("error.type", error.class.name)
-        raise
-      end
+    Riffer::Tracing.in_span(model ? "chat #{model}" : "chat", attributes: chat_span_attributes(model, options), kind: :client) do |span|
+      capture_input(span, messages)
+      yield span
     rescue => error
-      # The inner rescue tags the span; capture error.type here too, at method
-      # scope, where the ensure can read it onto the metric.
-      error_type = error.class.name #: String?
+      # The backend records the exception and error status on the re-raise;
+      # error.type is the one semconv attribute it doesn't set.
+      span.set_attribute("error.type", error.class.name)
       raise
-    ensure
-      Riffer::Metrics::Instruments::OPERATION_DURATION.record(Riffer::Metrics.monotonic_now - start, attributes: chat_metric_attributes(model, error_type, tags))
     end
   end
 
@@ -265,54 +241,14 @@ class Riffer::Providers::Base
     attributes.merge(tag_attributes(options[:tags] || {}))
   end
 
-  #--
-  #: (String?, ?Hash[String, String]) -> Hash[String, untyped]
-  def chat_metric_base_attributes(model, tags = {})
-    attributes = {
-      "gen_ai.operation.name" => "chat",
-      "gen_ai.provider.name" => self.class.semconv_provider_name
-    } #: Hash[String, untyped]
-    attributes["gen_ai.request.model"] = model if model
-    attributes.merge(tag_attributes(tags))
-  end
-
-  #--
-  #: (String?, String?, ?Hash[String, String]) -> Hash[String, untyped]
-  def chat_metric_attributes(model, error_type, tags = {})
-    attributes = chat_metric_base_attributes(model, tags)
-    attributes["error.type"] = error_type if error_type
-    attributes
-  end
-
-  # Maps normalized tags to their namespaced span/metric attribute form. An
-  # empty map yields an empty hash, so merging it is a no-op.
+  # Maps normalized tags to their namespaced span attribute form. An empty map
+  # yields an empty hash, so merging it is a no-op.
   #--
   #: (Hash[String, String]) -> Hash[String, String]
   def tag_attributes(tags)
     tags.transform_keys { |key| "riffer.tag.#{key}" }
   end
 
-  # Per-call only — the run level would double-count an aggregate.
-  #--
-  #: (String?, Riffer::Providers::TokenUsage?, ?Hash[String, String]) -> void
-  def record_token_usage_metric(model, usage, tags = {})
-    return unless usage
-
-    base = chat_metric_base_attributes(model, tags)
-    Riffer::Metrics::Instruments::TOKEN_USAGE.record(usage.input_tokens, attributes: base.merge("gen_ai.token.type" => "input"))
-    Riffer::Metrics::Instruments::TOKEN_USAGE.record(usage.output_tokens, attributes: base.merge("gen_ai.token.type" => "output"))
-  end
-
-  # Per-call only — the run level would double-count an aggregate.
-  #--
-  #: (String?, Riffer::Providers::TokenUsage?, ?Hash[String, String]) -> void
-  def record_cost_metric(model, usage, tags = {})
-    cost = usage&.cost
-    return unless cost
-
-    Riffer::Metrics::Instruments::COST.record(cost, attributes: chat_metric_base_attributes(model, tags))
-  end
-
   #--
   #: ((Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span), Symbol?, String?) -> void
   def record_finish_reason(span, reason, raw)

data/lib/riffer/tools/runtime.rb

@@ -23,7 +23,7 @@ class Riffer::Tools::Runtime
     # Each Runner worker runs in its own thread/fiber, where the OTEL context
     # starts empty — capture here so the execute_tool span parents correctly.
     # tags are an ordinary local captured in the block, so they reach the
-    # worker's span/metric without re-propagation.
+    # worker's span without re-propagation.
     trace_context = Riffer::Tracing.current_context
     @runner.map(tool_calls, context: context) do |tool_call|
       Riffer::Tracing.with_context(trace_context) do
@@ -61,22 +61,12 @@ class Riffer::Tools::Runtime
   #--
   #: (Riffer::Messages::Assistant::ToolCall, ?Hash[String, String]) { () -> Riffer::Tools::Response } -> [Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response]
   def instrument_tool_call(tool_call, tags = {})
-    start = Riffer::Metrics.monotonic_now
-    error_type = nil #: String?
-    begin
-      result = in_tool_span(tool_call, tags) do |span|
-        response = yield
-        record_tool_outcome(span, response)
-        response
-      end
-      error_type = result.error_type&.to_s
-      [tool_call, result] #: [Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response]
-    rescue => error
-      error_type = error.class.name #: String?
-      raise
-    ensure
-      Riffer::Metrics::Instruments::OPERATION_DURATION.record(Riffer::Metrics.monotonic_now - start, attributes: tool_metric_attributes(tool_call, error_type, tags))
+    result = in_tool_span(tool_call, tags) do |span|
+      response = yield
+      record_tool_outcome(span, response)
+      response
     end
+    [tool_call, result] #: [Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response]
   end
 
   #--
@@ -138,19 +128,8 @@ class Riffer::Tools::Runtime
     }.merge(tag_attributes(tags))
   end
 
-  #--
-  #: (Riffer::Messages::Assistant::ToolCall, String?, ?Hash[String, String]) -> Hash[String, untyped]
-  def tool_metric_attributes(tool_call, error_type, tags = {})
-    attributes = {
-      "gen_ai.operation.name" => "execute_tool",
-      "gen_ai.tool.name" => tool_call.name
-    } #: Hash[String, untyped]
-    attributes["error.type"] = error_type if error_type
-    attributes.merge(tag_attributes(tags))
-  end
-
-  # Maps normalized tags to their namespaced span/metric attribute form. An
-  # empty map yields an empty hash, so merging it is a no-op.
+  # Maps normalized tags to their namespaced span attribute form. An empty map
+  # yields an empty hash, so merging it is a no-op.
   #--
   #: (Hash[String, String]) -> Hash[String, String]
   def tag_attributes(tags)

data/lib/riffer/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Riffer
-  VERSION = "0.35.0" #: String
+  VERSION = "0.36.0" #: String
 end

data/sig/_private/opentelemetry.rbs

@@ -1,13 +1,10 @@
-# Minimal signatures for the `opentelemetry-api` and `opentelemetry-metrics-api`
-# gems (undeclared, runtime detected), which ship no RBS.
+# Minimal signatures for the `opentelemetry-api` gem (undeclared, runtime
+# detected), which ships no RBS.
 #
-# Only the surface used by Riffer::Tracing::Otel and Riffer::Metrics::Otel is
-# declared.
+# Only the surface used by Riffer::Tracing::Otel is declared.
 module OpenTelemetry
   def self.tracer_provider: () -> untyped
 
-  def self.meter_provider: () -> untyped
-
   class Context
     def self.current: () -> OpenTelemetry::Context
 

data/sig/generated/riffer/agent/run.rbs

@@ -21,8 +21,8 @@ module Riffer::Agent::Run
 
   # Both +generate+ and +stream+ funnel here, so this is the single place raw
   # +tags+ are normalized. The clean <tt>String => String</tt> map is then
-  # threaded to every span/metric builder in the run as +riffer.tag.*+ and to
-  # each provider call (via +merged_model_options+) for native request-metadata
+  # threaded to every span builder in the run as +riffer.tag.*+ and to each
+  # provider call (via +merged_model_options+) for native request-metadata
   # mapping.
   # --
   # : (Riffer::Agent, ?tags: Hash[(String | Symbol), untyped]?, ?stream_yielder: Enumerator::Yielder?) -> Riffer::Agent::Response
@@ -86,8 +86,8 @@ module Riffer::Agent::Run
 
   # +tags+ rides in the options hash as a curated key the providers extract for
   # native request-metadata mapping (alongside +:structured_output+); it never
-  # reaches an SDK call verbatim. Span/metric tagging is threaded separately to
-  # each builder.
+  # reaches an SDK call verbatim. Span tagging is threaded separately to each
+  # builder.
   # --
   # : (Riffer::Agent, ?Hash[String, String]) -> Hash[Symbol, untyped]
   def merged_model_options: (Riffer::Agent, ?Hash[String, String]) -> Hash[Symbol, untyped]
@@ -114,10 +114,6 @@ module Riffer::Agent::Run
   # : (Riffer::Agent, ?Hash[String, String]) -> Hash[String, untyped]
   def run_span_attributes: (Riffer::Agent, ?Hash[String, String]) -> Hash[String, untyped]
 
-  # --
-  # : (Riffer::Agent, String?, ?Hash[String, String]) -> Hash[String, untyped]
-  def run_metric_attributes: (Riffer::Agent, String?, ?Hash[String, String]) -> Hash[String, untyped]
-
   # --
   # : (Hash[(String | Symbol), untyped]?) -> Hash[String, String]
   def normalize_tags: (Hash[String | Symbol, untyped]?) -> Hash[String, String]

data/sig/generated/riffer/agent.rbs

@@ -215,7 +215,7 @@ class Riffer::Agent
   #
   # +tags:+ is an optional flat hash of attribution tags applied to this single
   # call: they propagate to the provider's native request-metadata field, and
-  # are stamped as +riffer.tag.*+ on every span and metric the call emits. See
+  # are stamped as +riffer.tag.*+ on every span the call emits. See
   # +docs/03_AGENTS.md+ for the per-provider mapping. The reserved key
   # +user_id+ also maps to the provider's native user identifier where one
   # exists.

data/sig/generated/riffer/config.rbs

@@ -137,36 +137,6 @@ class Riffer::Config
     def backend=: (untyped) -> void
   end
 
-  # Metrics-related global configuration, independent of +config.tracing+ so a
-  # host can run one signal without the other.
-  class Metrics
-    # Whether riffer records OTEL metric instruments; defaults to +true+, a
-    # no-op until a host wires an OTEL metrics SDK.
-    attr_reader enabled: bool
-
-    # The backend riffer routes measurements through; defaults to +nil+, a no-op.
-    # Riffer auto-detects no backend; assigning one is opt-in.
-    attr_reader backend: untyped
-
-    # --
-    # : () -> void
-    def initialize: () -> void
-
-    # Sets the enabled flag, coercing boolean-ish values so an env-var
-    # +"false"+ (truthy in Ruby) doesn't silently keep metrics on. Raises
-    # Riffer::ArgumentError on an unrecognized value.
-    # --
-    # : (untyped) -> void
-    def enabled=: (untyped) -> void
-
-    # Sets the metrics backend riffer routes measurements through. Raises
-    # Riffer::ArgumentError unless the value is +nil+ or responds to
-    # +record_histogram+.
-    # --
-    # : (untyped) -> void
-    def backend=: (untyped) -> void
-  end
-
   # Consumer-configured token pricing, keyed by +provider/model+ id. Riffer
   # ships no price table, so an unconfigured model carries no cost.
   class Pricing
@@ -276,9 +246,6 @@ class Riffer::Config
   # Tracing-related global configuration.
   attr_reader tracing: Riffer::Config::Tracing
 
-  # Metrics-related global configuration.
-  attr_reader metrics: Riffer::Config::Metrics
-
   # Consumer-configured per-model token pricing.
   attr_reader pricing: Riffer::Config::Pricing