rails-profiler 0.39.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bc10ed77cb2126254ad1b94fb697766bd7e8305fdeb957e7a5dd44909e622dd
-  data.tar.gz: d250a8a1b41ea1668b6835cbf07a0371422fa90b3c820be182da4c6734e82dd1
+  metadata.gz: 312d0ee269f45025f4192fd8e7491d90835e4d2da0a9ddfdbda6429644615981
+  data.tar.gz: 4dd491cba56414e4ed0291ff492e644cd6264a27e6830da54f23caebfcb9d666
 SHA512:
-  metadata.gz: 9c5c4774740ee3f12f3411cba23c3ff0c9c2f28db248d50a1d84f800a5a66d59bff11016f761d4fd1639105a854217c7190ebd5753febfaac08a3c80b1228eb2
-  data.tar.gz: 41d9f3e676848d74bd27c02062d0fe593f12c50aa2ef7de62f7bc1913e6a6ba8816858fade838969eaf1aacb1ca83a13a8f722215a0d4c72b2cdddeed76c6fa9
+  metadata.gz: 20de3f4b06ce2e7827a12fc8d5304428cc7865414b820177001957c155e4e18afa0bbd8fb0acef04d624ee609cc9473d1cf2eb456699b4bdbfdc241b8ff06ec2
+  data.tar.gz: beea47dda7f64599af19dd12c44531cdc9c9310c6069782754a2295ff2df5a11aedee1cc1f14c407b2be2f38c8d89b6aedc228405d74eddaf0ead39a08f704e3

data/CHANGELOG.md

@@ -19,6 +19,14 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.40.0] - 2026-10-19
+
+<!-- stamped -->
+
+### Added
+
+- **OpenTelemetry:** with the same `config.otel_enabled = true`, each profiled request also records metrics: duration histograms (request, SQL query, view, cache operation, outbound `Net::HTTP` call) and counters for allocated objects and for requests that ran an N+1. Attributes are low-cardinality on purpose: `controller#action`, HTTP method and status, SQL verb and cache operation, never a token, URL or SQL text. **Experimental:** it needs `opentelemetry-metrics-api`, `opentelemetry-metrics-sdk` and `opentelemetry-exporter-otlp-metrics` in the application's `Gemfile`, pinned to an exact version because the metrics SDK is alpha; without them one message is logged and traces are unaffected.
+
 ## [0.39.0] - 2026-10-19
 
 <!-- stamped -->

data/lib/profiler/middleware/profiler_middleware.rb

@@ -5,6 +5,7 @@ require_relative "../models/profile"
 require_relative "../current_context"
 require_relative "../trace_context"
 require_relative "../otel/trace_exporter"
+require_relative "../otel/metrics_exporter"
 require_relative "../collectors/lifecycle"
 require_relative "toolbar_injector"
 require_relative "capturing_body"
@@ -223,12 +224,13 @@ module Profiler
         Profiler.log_error("ProfilerMiddleware: could not finish the profile of a streamed response", e)
       end
 
-      # The profile is saved, then sent to OpenTelemetry when config.otel_enabled asks for it:
+      # The profile is saved, then sent to OpenTelemetry (spans, then metrics) when config.otel_enabled asks for it:
       # once per profile, here, and not from Profiler.save_profile, which a profile reaches again
       # whenever a late outbound call completes. The export never raises.
       def save_and_export(profile)
         saved = Profiler.save_profile(profile, from: "ProfilerMiddleware")
         Otel::TraceExporter.export(profile)
+        Otel::MetricsExporter.export(profile)
         saved
       end
 

data/lib/profiler/otel/metrics_exporter.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "sdk"
+require_relative "trace_exporter"
+require_relative "../mcp/resources/n1_patterns"
+
+module Profiler
+  module Otel
+    # Records a finished request profile in OpenTelemetry metrics: duration histograms (request,
+    # SQL query, view or partial, cache operation, outbound HTTP call; milliseconds, the unit the
+    # profiler measures in), a counter of the objects the request allocated, and a counter of the
+    # requests that ran an N+1. The events are the ones TraceExporter turns into spans, here
+    # aggregated.
+    #
+    # Attributes are kept to a bounded set of values, on purpose (unlike spans, a metric is one
+    # time series per attribute combination): controller#action (or "unknown"), the HTTP method
+    # (a standard verb, else "_OTHER"), the status code (request duration only), the SQL verb
+    # (SELECT, INSERT, UPDATE, DELETE, else "OTHER") and the cache operation. Never a profile
+    # token, a path or URL, SQL text, a cache key or a host.
+    #
+    # The metrics SDK is alpha: its API moves between releases (see docs/configuration.md).
+    # Does nothing, and touches nothing of OpenTelemetry, unless config.otel_enabled is true.
+    # Never raises: a failure is logged and the request goes on.
+    module MetricsExporter
+      SCOPE_NAME = "profiler"
+      UNKNOWN = "unknown"
+      HTTP_METHODS = %w[GET HEAD POST PUT PATCH DELETE OPTIONS CONNECT TRACE].freeze
+      SQL_VERBS = %w[SELECT INSERT UPDATE DELETE].freeze
+
+      module_function
+
+      def export(profile)
+        return false unless Profiler.configuration.otel_enabled
+
+        provider = Sdk.meter_provider
+        return false unless provider
+
+        record(instruments(provider), profile)
+        true
+      rescue StandardError => e
+        Profiler.log_error_once(:otel_metrics_export, "OpenTelemetry metrics export of a profile failed", e)
+        false
+      end
+
+      # The instruments of a provider (the meter caches them by name, so asking again is cheap).
+      def instruments(provider)
+        meter = provider.meter(SCOPE_NAME, version: Profiler.version)
+        {
+          request: meter.create_histogram("profiler.request.duration", unit: "ms",
+                                                                       description: "Duration of a profiled HTTP request"),
+          sql: meter.create_histogram("profiler.db.query.duration", unit: "ms",
+                                                                    description: "Duration of a SQL query"),
+          view: meter.create_histogram("profiler.view.render.duration", unit: "ms",
+                                                                        description: "Duration of a view or partial render"),
+          cache: meter.create_histogram("profiler.cache.operation.duration", unit: "ms",
+                                                                             description: "Duration of a cache operation"),
+          http: meter.create_histogram("profiler.http.client.request.duration", unit: "ms",
+                                                                                description: "Duration of an outbound Net::HTTP call"),
+          allocations: meter.create_counter("profiler.request.allocations", unit: "{object}",
+                                                                            description: "Objects allocated by profiled requests"),
+          n_plus_one: meter.create_counter("profiler.request.n_plus_one", unit: "{request}",
+                                                                          description: "Profiled requests that ran an N+1 query")
+        }
+      end
+
+      def record(instruments, profile)
+        data = profile.collectors_data || {}
+        base = { "profiler.controller_action" => controller_action(data), "http.request.method" => method_name(profile.method) }
+
+        request_attributes = base.dup
+        request_attributes["http.response.status_code"] = profile.status.to_i if (100..599).cover?(profile.status.to_i)
+        instruments[:request].record(profile.duration.to_f, attributes: request_attributes) if profile.duration
+
+        queries = queries(data)
+        queries.each do |query|
+          instruments[:sql].record(query[:duration].to_f, attributes: base.merge("db.operation.name" => sql_verb(query[:sql])))
+        end
+        record_all(instruments[:view], base, views(data))
+        record_cache(instruments[:cache], base, data)
+        record_all(instruments[:http], base, TraceExporter.list(TraceExporter.fetch(data, "http"), :requests).reject { |r| r[:in_flight] })
+
+        allocations = profile.allocated_objects
+        instruments[:allocations].add(allocations, attributes: base) if allocations.is_a?(Integer) && allocations.positive?
+        instruments[:n_plus_one].add(1, attributes: base) if n_plus_one?(queries)
+      end
+
+      def record_all(histogram, attributes, events)
+        events.each { |event| histogram.record(event[:duration].to_f, attributes: attributes) if event[:duration] }
+      end
+
+      def record_cache(histogram, base, data)
+        cache = TraceExporter.fetch(data, "cache")
+        %i[reads writes deletes].each do |kind|
+          operation = kind.to_s.chomp("s")
+          TraceExporter.list(cache, kind).each do |event|
+            next unless event[:duration]
+
+            histogram.record(event[:duration].to_f, attributes: base.merge("cache.operation" => operation))
+          end
+        end
+      end
+
+      def views(data)
+        view = TraceExporter.fetch(data, "view")
+        TraceExporter.list(view, :views) + TraceExporter.list(view, :partials)
+      end
+
+      # The SQL queries of the request, transaction statements apart (the Database tab does too).
+      def queries(data)
+        TraceExporter.list(TraceExporter.fetch(data, "database"), :queries).reject { |q| q[:transaction] || q[:duration].nil? }
+      end
+
+      # An N+1 here: some query, once its constants are normalized (N1Patterns.normalize_sql, the
+      # one the n1-patterns resource uses), ran more than once within this one request.
+      def n_plus_one?(queries)
+        queries.group_by { |q| MCP::Resources::N1Patterns.normalize_sql(q[:sql].to_s) }.any? { |_, group| group.size > 1 }
+      end
+
+      def controller_action(data)
+        value = TraceExporter.fetch(data, "request")[:controller_action] || TraceExporter.fetch(data, "request")["controller_action"]
+        value.to_s.empty? ? UNKNOWN : value.to_s
+      end
+
+      def method_name(method)
+        name = method.to_s.upcase
+        HTTP_METHODS.include?(name) ? name : "_OTHER"
+      end
+
+      def sql_verb(sql)
+        verb = sql.to_s[/\A\s*(\w+)/, 1].to_s.upcase
+        SQL_VERBS.include?(verb) ? verb : "OTHER"
+      end
+    end
+  end
+end

data/lib/profiler/otel/sdk.rb

@@ -9,38 +9,56 @@ module Profiler
     # requires "opentelemetry/..." and the only one that reaches the OpenTelemetry constants, and
     # it does so only once config.otel_enabled is true: the gem declares no dependency on
     # OpenTelemetry (like stackprof, it is optional), so an application that never heard of it
-    # loads and profiles exactly as before. Written so that metrics can share it: +available?+,
-    # +resource+ and the OTLP settings are not specific to traces.
+    # loads and profiles exactly as before. Traces and metrics share it: the detection of the
+    # application's own provider, the resource and the OTLP settings are the same, only the gems
+    # and the provider class differ (see SIGNALS). Each signal is decided on its own, so the
+    # trace gems without the metrics ones (or the reverse) gives one signal and a warning for the
+    # other.
     module Sdk
       LOCK = Monitor.new
-      REQUIRES = ["opentelemetry/sdk", "opentelemetry/exporter/otlp"].freeze
-      ENDPOINT_ENV = %w[OTEL_EXPORTER_OTLP_TRACES_ENDPOINT OTEL_EXPORTER_OTLP_ENDPOINT].freeze
 
-      @state = nil
+      # What differs between the signals: the gems to load, the API's global provider accessor,
+      # the SDK class of a provider, and the standard endpoint variables.
+      SIGNALS = {
+        traces: {
+          requires: ["opentelemetry/sdk", "opentelemetry/exporter/otlp"],
+          gems: "opentelemetry-sdk and opentelemetry-exporter-otlp",
+          endpoint_env: %w[OTEL_EXPORTER_OTLP_TRACES_ENDPOINT OTEL_EXPORTER_OTLP_ENDPOINT].freeze
+        },
+        metrics: {
+          requires: ["opentelemetry/sdk", "opentelemetry-metrics-sdk", "opentelemetry/exporter/otlp_metrics"],
+          gems: "opentelemetry-metrics-api, opentelemetry-metrics-sdk and opentelemetry-exporter-otlp-metrics " \
+                "(alpha, pin an exact version of each)",
+          endpoint_env: %w[OTEL_EXPORTER_OTLP_METRICS_ENDPOINT OTEL_EXPORTER_OTLP_ENDPOINT].freeze
+        }
+      }.freeze
+      ENDPOINT_ENV = SIGNALS.dig(:traces, :endpoint_env)
+
+      @state = {}
+      @available = {}
 
       class << self
         # The tracer provider spans are started from, nil when export is off or cannot work. Warns
         # once (Profiler.log_error) when it cannot; never raises.
         def tracer_provider
-          return nil unless Profiler.configuration.otel_enabled
+          provider_for(:traces) { setup(:traces, :host_tracer_provider, :build_own_tracer_provider) { |p| scoped(p) } }
+        end
 
-          state = @state || LOCK.synchronize { @state ||= setup_tracer_provider }
-          state[:provider]
-        rescue StandardError, LoadError => e
-          LOCK.synchronize { @state = { provider: nil } }
-          Profiler.log_error("OpenTelemetry export disabled: setup failed", e)
-          nil
+        # The meter provider metrics are recorded with, nil when export is off or cannot work. The
+        # application's SDK MeterProvider when it has one, else our own, never installed globally.
+        def meter_provider
+          provider_for(:metrics) { setup(:metrics, :host_meter_provider, :build_own_meter_provider) }
         end
 
-        # Whether the SDK and the OTLP exporter can be loaded. Loads them (the sole place that
-        # does), and says so in the log once if they cannot.
-        def available?
-          return @available unless @available.nil?
+        # Whether the SDK and the OTLP exporter of a signal can be loaded. Loads them (the sole
+        # place that does), and says so in the log once if they cannot.
+        def available?(signal = :traces)
+          return @available[signal] unless @available[signal].nil?
 
           LOCK.synchronize do
-            return @available unless @available.nil?
+            return @available[signal] unless @available[signal].nil?
 
-            @available = load_gems
+            @available[signal] = load_gems(signal)
           end
         end
 
@@ -51,11 +69,14 @@ module Profiler
 
         # The endpoint the profiler's own exporter posts to: otel_otlp_endpoint, else the standard
         # OTEL_EXPORTER_OTLP_* variables the exporter itself reads. nil when neither is set.
-        def otlp_endpoint
+        def otlp_endpoint(signal = :traces)
           configured = Profiler.configuration.otel_otlp_endpoint.to_s.strip
-          return configured unless configured.empty?
+          unless configured.empty?
+            # One setting serves both signals: the traces path means the metrics one.
+            return signal == :metrics ? configured.sub(%r{/v1/traces/?\z}, "/v1/metrics") : configured
+          end
 
-          ENDPOINT_ENV.each do |name|
+          SIGNALS.fetch(signal)[:endpoint_env].each do |name|
             value = ENV[name].to_s.strip
             return value unless value.empty?
           end
@@ -65,33 +86,45 @@ module Profiler
         # Forgets everything decided so far (the specs, and a configuration change).
         def reset!
           LOCK.synchronize do
-            @state = nil
-            @available = nil
+            @state = {}
+            @available = {}
           end
         end
 
         private
 
-        def load_gems
-          REQUIRES.each { |name| require name }
+        # The provider of a signal: nil when export is off, decided once (in the block), nil with
+        # one logged error when the setup raises.
+        def provider_for(signal)
+          return nil unless Profiler.configuration.otel_enabled
+
+          state = @state[signal] || LOCK.synchronize { @state[signal] ||= yield }
+          state[:provider]
+        rescue StandardError, LoadError => e
+          LOCK.synchronize { @state[signal] = { provider: nil } }
+          Profiler.log_error("OpenTelemetry #{signal} export disabled: setup failed", e)
+          nil
+        end
+
+        def load_gems(signal)
+          SIGNALS.fetch(signal)[:requires].each { |name| require name }
           true
         rescue LoadError => e
           Profiler.log_error(
-            "config.otel_enabled is true but the OpenTelemetry gems are not available (#{e.message}); " \
-            "add opentelemetry-sdk and opentelemetry-exporter-otlp to the application's Gemfile. " \
-            "OpenTelemetry export is off."
+            "config.otel_enabled is true but the OpenTelemetry #{signal} gems are not available " \
+            "(#{e.message}); add #{SIGNALS.fetch(signal)[:gems]} to the application's Gemfile. " \
+            "OpenTelemetry #{signal} export is off."
           )
           false
         end
 
-        def setup_tracer_provider
-          return { provider: nil } unless available?
-
-          existing = host_tracer_provider
-          return { provider: scoped(existing) } if existing
+        # The host's provider when it has one (then prepared by the block, if any), else our own.
+        def setup(signal, host_finder, builder)
+          return { provider: nil } unless available?(signal)
 
-          own = build_own_tracer_provider
-          { provider: own && scoped(own) }
+          provider = send(host_finder) || send(builder)
+          provider = yield(provider) if provider && block_given?
+          { provider: provider }
         end
 
         # The SDK provider the application initialised for itself, if any. The API's global
@@ -99,35 +132,56 @@ module Profiler
         def host_tracer_provider
           provider = OpenTelemetry.tracer_provider
           provider = provider.delegate if provider.respond_to?(:delegate)
-          sdk_provider?(provider) ? provider : nil
+          provider if defined?(OpenTelemetry::SDK::Trace::TracerProvider) &&
+                      provider.is_a?(OpenTelemetry::SDK::Trace::TracerProvider)
         end
 
-        def sdk_provider?(provider)
-          defined?(OpenTelemetry::SDK::Trace::TracerProvider) &&
-            provider.is_a?(OpenTelemetry::SDK::Trace::TracerProvider)
+        def host_meter_provider
+          provider = OpenTelemetry.meter_provider
+          provider = provider.delegate if provider.respond_to?(:delegate)
+          provider if defined?(OpenTelemetry::SDK::Metrics::MeterProvider) &&
+                      provider.is_a?(OpenTelemetry::SDK::Metrics::MeterProvider)
+        end
+
+        # The endpoint of our own exporter, nil (after one logged error) when there is none.
+        def endpoint_or_warn(signal)
+          endpoint = otlp_endpoint(signal)
+          return endpoint if endpoint
+
+          Profiler.log_error(
+            "config.otel_enabled is true but there is no OpenTelemetry SDK in the application and " \
+            "config.otel_otlp_endpoint is not set: OpenTelemetry #{signal} export is off."
+          )
+          nil
+        end
+
+        def resource
+          OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
         end
 
         # Our own provider, never installed as the global one: the application's OpenTelemetry
         # stays as it is. OTLP over http/protobuf, the protocol of opentelemetry-exporter-otlp.
         def build_own_tracer_provider
-          endpoint = otlp_endpoint
-          unless endpoint
-            Profiler.log_error(
-              "config.otel_enabled is true but there is no OpenTelemetry SDK in the application and " \
-              "config.otel_otlp_endpoint is not set: OpenTelemetry export is off."
-            )
-            return nil
-          end
+          endpoint = endpoint_or_warn(:traces) or return nil
 
           exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(endpoint: endpoint)
-          provider = OpenTelemetry::SDK::Trace::TracerProvider.new(
-            resource: OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
-          )
+          provider = OpenTelemetry::SDK::Trace::TracerProvider.new(resource: resource)
           provider.add_span_processor(OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(exporter))
           at_exit { provider.shutdown }
           provider
         end
 
+        # Same, for metrics: a periodic reader pushes what was recorded to the OTLP metrics exporter.
+        def build_own_meter_provider
+          endpoint = endpoint_or_warn(:metrics) or return nil
+
+          exporter = OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter.new(endpoint: endpoint)
+          provider = OpenTelemetry::SDK::Metrics::MeterProvider.new(resource: resource)
+          provider.add_metric_reader(OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(exporter: exporter))
+          at_exit { provider.shutdown }
+          provider
+        end
+
         # The provider with its id generator wrapped, once.
         def scoped(provider)
           unless provider.respond_to?(:id_generator=)

data/lib/profiler/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.39.0"
+  VERSION = "0.40.0"
 
   GEM_ROOT = File.expand_path("../..", __dir__)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.39.0
+  version: 0.40.0
 platform: ruby
 authors:
 - Sébastien Duplessy
@@ -235,6 +235,7 @@ files:
 - lib/profiler/models/profile.rb
 - lib/profiler/models/sql_query.rb
 - lib/profiler/models/timeline_event.rb
+- lib/profiler/otel/metrics_exporter.rb
 - lib/profiler/otel/scoped_id_generator.rb
 - lib/profiler/otel/sdk.rb
 - lib/profiler/otel/trace_exporter.rb