otlp_rails 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4777fd19cdf39779247e804d59bec7b1f0bab16a9954f1b331501583fbae5f4f
+  data.tar.gz: 4c48473532ca764aba7fd5cf96d78da9c85331403479b58f847b6bf6b3bb17f9
+SHA512:
+  metadata.gz: a0ecffbb198ff471731f47a5ed722d29120af32e7493c58f698883672328a94070099f88f51ac9c8ccde63159b0bd8af64689f397287eb7a31d05d9306188987
+  data.tar.gz: b1a650a217462df121bd6d12d092a68be276fa6a42691bbe5f3b25175e3497b2f1ead05d2d0215e03eee8a1d5735db9be3e1b85fe00cb59f0fddfee5bc1198c6

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## [0.2.0](https://github.com/endoze/otlp_rails/compare/otlp_rails-v0.1.0...otlp_rails/v0.2.0) (2026-04-03)
+
+
+### Features
+
+* initial release of otlp_rails ([#7](https://github.com/endoze/otlp_rails/issues/7)) ([45a791b](https://github.com/endoze/otlp_rails/commit/45a791bd3194a0b9172959f581f16ee499dbea09))
+
+## [0.1.0] - Unreleased
+
+- Initial release
+- ActionController request metrics (duration histogram, request counter)
+- ActiveRecord query metrics (duration histogram, query counter)
+- ActiveJob job metrics (perform duration/count, enqueue count)
+- Hybrid MeterProvider discovery (reuse existing or provision standalone)
+- Pluggable subscriber architecture for custom metrics
+- Rails Railtie for zero-config integration

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Endoze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/otlp_rails/configuration.rb

@@ -0,0 +1,43 @@
+module OTLPRails
+  class Configuration
+    attr_accessor :metric_prefix,
+      :otlp_endpoint,
+      :export_interval_millis,
+      :export_timeout_millis,
+      :resource_attributes
+
+    attr_reader :subscriber_settings, :custom_subscribers
+
+    def initialize
+      @metric_prefix = "rails"
+      @otlp_endpoint = nil
+      @export_interval_millis = 60_000
+      @export_timeout_millis = 30_000
+      @resource_attributes = {}
+
+      @subscriber_settings = {
+        action_controller: {enabled: true},
+        active_record: {enabled: true},
+        active_job: {enabled: true}
+      }
+
+      @custom_subscribers = []
+    end
+
+    def enable_subscriber(name)
+      @subscriber_settings[name][:enabled] = true if @subscriber_settings.key?(name)
+    end
+
+    def disable_subscriber(name)
+      @subscriber_settings[name][:enabled] = false if @subscriber_settings.key?(name)
+    end
+
+    def subscriber_enabled?(name)
+      @subscriber_settings.dig(name, :enabled) != false
+    end
+
+    def add_subscriber(subscriber_class)
+      @custom_subscribers << subscriber_class
+    end
+  end
+end

data/lib/otlp_rails/meter_provider_resolver.rb

@@ -0,0 +1,73 @@
+require "opentelemetry-metrics-api"
+
+module OTLPRails
+  class MeterProviderResolver
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def resolve
+      existing = detect_existing_provider
+      return existing if existing
+
+      provision_standalone_provider
+    end
+
+    private
+
+    def detect_existing_provider
+      provider = OpenTelemetry.meter_provider
+
+      return if !provider.is_a?(OpenTelemetry::SDK::Metrics::MeterProvider)
+      return if provider.metric_readers.none?
+
+      log(:info,
+        "Discovered existing SDK MeterProvider " \
+        "with #{provider.metric_readers.size} reader(s); reusing it.")
+
+      provider
+    rescue NameError
+      nil
+    end
+
+    def provision_standalone_provider
+      require "opentelemetry/sdk"
+      require "opentelemetry-metrics-sdk"
+      require "opentelemetry/exporter/otlp_metrics"
+
+      resource = build_resource
+      provider = OpenTelemetry::SDK::Metrics::MeterProvider.new(resource: resource)
+
+      exporter_opts = {}
+      exporter_opts[:endpoint] = @configuration.otlp_endpoint if @configuration.otlp_endpoint
+      exporter = OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter.new(**exporter_opts)
+
+      periodic_reader = OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+        exporter: exporter,
+        export_interval_millis: @configuration.export_interval_millis,
+        export_timeout_millis: @configuration.export_timeout_millis
+      )
+      provider.add_metric_reader(periodic_reader)
+
+      OpenTelemetry.meter_provider = provider
+
+      log(:info,
+        "Provisioned standalone MeterProvider " \
+        "exporting to #{@configuration.otlp_endpoint || "default OTLP endpoint"}.")
+
+      provider
+    end
+
+    def log(level, message)
+      Rails.logger.send(level, "[otlp_rails] #{message}") if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+    end
+
+    def build_resource
+      attrs = {
+        "service.name" => ENV.fetch("OTEL_SERVICE_NAME", "rails-app")
+      }.merge(@configuration.resource_attributes)
+
+      OpenTelemetry::SDK::Resources::Resource.create(attrs)
+    end
+  end
+end

data/lib/otlp_rails/railtie.rb

@@ -0,0 +1,8 @@
+module OTLPRails
+  class Railtie < ::Rails::Railtie
+    initializer "otlp_rails.subscribe",
+      after: :load_config_initializers do
+      OTLPRails.subscribe!
+    end
+  end
+end

data/lib/otlp_rails/subscriber.rb

@@ -0,0 +1,62 @@
+module OTLPRails
+  class Subscriber
+    attr_reader :meter, :subscriptions
+
+    def initialize(meter)
+      @meter = meter
+      @instruments = {}
+      @subscriptions = []
+      setup_instruments
+    end
+
+    def self.events
+      raise NotImplementedError, "#{name} must implement .events"
+    end
+
+    def setup_instruments
+      raise NotImplementedError, "#{self.class.name} must implement #setup_instruments"
+    end
+
+    def on_event(name, started, finished, unique_id, payload)
+      raise NotImplementedError, "#{self.class.name} must implement #on_event"
+    end
+
+    def subscribe!
+      return if self.class.events.none?
+
+      self.class.events.each do |event_name|
+        subscription = ActiveSupport::Notifications.subscribe(event_name) do |name, started, finished, unique_id, payload|
+          on_event(name, started, finished, unique_id, payload)
+        rescue => e
+          if !defined?(Rails) || !Rails.respond_to?(:logger) || !Rails.logger
+            next
+          end
+
+          Rails.logger.warn(
+            "[otlp_rails] Error in #{self.class.name} " \
+            "handling #{name}: #{e.message}"
+          )
+        end
+        @subscriptions << subscription
+      end
+    end
+
+    def unsubscribe!
+      @subscriptions.each do |subscription|
+        ActiveSupport::Notifications.unsubscribe(subscription)
+      end
+      @subscriptions.clear
+    end
+
+    private
+
+    def duration_ms(started, finished)
+      (finished - started) * 1000.0
+    end
+
+    def metric_name(suffix)
+      prefix = OTLPRails.configuration.metric_prefix
+      "#{prefix}.#{suffix}"
+    end
+  end
+end

data/lib/otlp_rails/subscriber_registry.rb

@@ -0,0 +1,40 @@
+require "singleton"
+
+module OTLPRails
+  class SubscriberRegistry
+    include Singleton
+
+    BUILT_IN_SUBSCRIBERS = {
+      action_controller: Subscribers::ActionControllerSubscriber,
+      active_record: Subscribers::ActiveRecordSubscriber,
+      active_job: Subscribers::ActiveJobSubscriber
+    }.freeze
+
+    def initialize
+      @active_subscribers = []
+    end
+
+    def subscribe_all(meter)
+      config = OTLPRails.configuration
+
+      BUILT_IN_SUBSCRIBERS.each do |name, klass|
+        next if !config.subscriber_enabled?(name)
+
+        subscriber = klass.new(meter)
+        subscriber.subscribe!
+        @active_subscribers << subscriber
+      end
+
+      config.custom_subscribers.each do |klass|
+        subscriber = klass.new(meter)
+        subscriber.subscribe!
+        @active_subscribers << subscriber
+      end
+    end
+
+    def unsubscribe_all
+      @active_subscribers.each(&:unsubscribe!)
+      @active_subscribers.clear
+    end
+  end
+end

data/lib/otlp_rails/subscribers/action_controller_subscriber.rb

@@ -0,0 +1,37 @@
+module OTLPRails
+  module Subscribers
+    class ActionControllerSubscriber < Subscriber
+      def self.events
+        ["process_action.action_controller"]
+      end
+
+      def setup_instruments
+        @instruments[:request_duration] = meter.create_histogram(
+          metric_name("http.request.duration"),
+          unit: "ms",
+          description: "Duration of HTTP requests processed by Rails controllers"
+        )
+
+        @instruments[:request_count] = meter.create_counter(
+          metric_name("http.request.count"),
+          unit: "requests",
+          description: "Total number of HTTP requests processed by Rails controllers"
+        )
+      end
+
+      def on_event(_name, started, finished, _unique_id, payload)
+        attributes = {
+          "controller" => payload[:controller].to_s,
+          "action" => payload[:action].to_s,
+          "status" => payload[:status].to_s,
+          "method" => payload[:method].to_s
+        }
+
+        duration = duration_ms(started, finished)
+
+        @instruments[:request_duration].record(duration, attributes: attributes)
+        @instruments[:request_count].add(1, attributes: attributes)
+      end
+    end
+  end
+end

data/lib/otlp_rails/subscribers/active_job_subscriber.rb

@@ -0,0 +1,71 @@
+module OTLPRails
+  module Subscribers
+    class ActiveJobSubscriber < Subscriber
+      def self.events
+        [
+          "perform.active_job",
+          "enqueue.active_job",
+          "enqueue_at.active_job"
+        ]
+      end
+
+      def setup_instruments
+        @instruments[:perform_duration] = meter.create_histogram(
+          metric_name("job.perform.duration"),
+          unit: "ms",
+          description: "Duration of ActiveJob job execution"
+        )
+
+        @instruments[:perform_count] = meter.create_counter(
+          metric_name("job.perform.count"),
+          unit: "jobs",
+          description: "Total number of ActiveJob jobs performed"
+        )
+
+        @instruments[:enqueue_count] = meter.create_counter(
+          metric_name("job.enqueue.count"),
+          unit: "jobs",
+          description: "Total number of ActiveJob jobs enqueued"
+        )
+      end
+
+      def on_event(name, started, finished, _unique_id, payload)
+        case name
+        when "perform.active_job"
+          record_perform(started, finished, payload)
+        when "enqueue.active_job", "enqueue_at.active_job"
+          record_enqueue(payload)
+        end
+      end
+
+      private
+
+      def record_perform(started, finished, payload)
+        job = payload[:job]
+        status = payload[:exception_object] ? "error" : "success"
+
+        attributes = {
+          "job_class" => job.class.name,
+          "queue_name" => job.queue_name.to_s,
+          "status" => status
+        }
+
+        duration = duration_ms(started, finished)
+
+        @instruments[:perform_duration].record(duration, attributes: attributes)
+        @instruments[:perform_count].add(1, attributes: attributes)
+      end
+
+      def record_enqueue(payload)
+        job = payload[:job]
+
+        attributes = {
+          "job_class" => job.class.name,
+          "queue_name" => job.queue_name.to_s
+        }
+
+        @instruments[:enqueue_count].add(1, attributes: attributes)
+      end
+    end
+  end
+end

data/lib/otlp_rails/subscribers/active_record_subscriber.rb

@@ -0,0 +1,52 @@
+module OTLPRails
+  module Subscribers
+    class ActiveRecordSubscriber < Subscriber
+      OPERATION_REGEX = /\A\s*(SELECT|INSERT|UPDATE|DELETE)/i
+      SKIP_NAMES = ["SCHEMA", "EXPLAIN"].freeze
+
+      def self.events
+        ["sql.active_record"]
+      end
+
+      def setup_instruments
+        @instruments[:query_duration] = meter.create_histogram(
+          metric_name("db.query.duration"),
+          unit: "ms",
+          description: "Duration of SQL queries executed by ActiveRecord"
+        )
+
+        @instruments[:query_count] = meter.create_counter(
+          metric_name("db.query.count"),
+          unit: "queries",
+          description: "Total number of SQL queries executed by ActiveRecord"
+        )
+      end
+
+      def on_event(_name, started, finished, _unique_id, payload)
+        return if payload[:name].nil? || payload[:name].to_s.empty?
+        return if SKIP_NAMES.include?(payload[:name])
+        return if payload[:sql].nil? || payload[:sql].to_s.empty?
+
+        operation = extract_operation(payload[:sql])
+        return if !operation
+
+        attributes = {
+          "operation" => operation,
+          "name" => payload[:name].to_s
+        }
+
+        duration = duration_ms(started, finished)
+
+        @instruments[:query_duration].record(duration, attributes: attributes)
+        @instruments[:query_count].add(1, attributes: attributes)
+      end
+
+      private
+
+      def extract_operation(sql)
+        match = sql.match(OPERATION_REGEX)
+        match ? match[1].upcase : nil
+      end
+    end
+  end
+end

data/lib/otlp_rails/version.rb

@@ -0,0 +1,3 @@
+module OTLPRails
+  VERSION = "0.2.0"
+end

data/lib/otlp_rails.rb

@@ -0,0 +1,48 @@
+require "otlp_rails/version"
+require "otlp_rails/configuration"
+require "otlp_rails/meter_provider_resolver"
+require "otlp_rails/subscriber"
+require "otlp_rails/subscribers/action_controller_subscriber"
+require "otlp_rails/subscribers/active_record_subscriber"
+require "otlp_rails/subscribers/active_job_subscriber"
+require "otlp_rails/subscriber_registry"
+require "otlp_rails/railtie" if defined?(Rails::Railtie)
+
+module OTLPRails
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :meter
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def reset!
+      @configuration = Configuration.new
+      @meter = nil
+
+      SubscriberRegistry.instance.unsubscribe_all
+    end
+
+    def subscribe!
+      resolver = MeterProviderResolver.new(configuration)
+      meter_provider = resolver.resolve
+
+      self.meter = meter_provider.meter(
+        "otlp_rails",
+        version: VERSION
+      )
+
+      SubscriberRegistry.instance.subscribe_all(meter)
+    end
+
+    def unsubscribe!
+      SubscriberRegistry.instance.unsubscribe_all
+    end
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: otlp_rails
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Endoze
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-metrics-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-metrics-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp-metrics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Subscribes to Rails instrumentation events and records OpenTelemetry
+  metrics, pushing them via OTLP. Works standalone or alongside an existing OpenTelemetry
+  SDK setup.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- lib/otlp_rails.rb
+- lib/otlp_rails/configuration.rb
+- lib/otlp_rails/meter_provider_resolver.rb
+- lib/otlp_rails/railtie.rb
+- lib/otlp_rails/subscriber.rb
+- lib/otlp_rails/subscriber_registry.rb
+- lib/otlp_rails/subscribers/action_controller_subscriber.rb
+- lib/otlp_rails/subscribers/active_job_subscriber.rb
+- lib/otlp_rails/subscribers/active_record_subscriber.rb
+- lib/otlp_rails/version.rb
+homepage: https://github.com/endoze/otlp_rails
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Rails ActiveSupport::Notifications to OpenTelemetry metrics via OTLP push
+test_files: []