miniapm 1.0.0

data/lib/miniapm/instrumentations/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    class Base
+      class << self
+        def install!
+          raise NotImplementedError, "Subclass must implement .install!"
+        end
+
+        def installed?
+          @installed || false
+        end
+
+        protected
+
+        def mark_installed!
+          @installed = true
+        end
+
+        def subscribe(event_name, &block)
+          ActiveSupport::Notifications.subscribe(event_name) do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            block.call(event)
+          rescue StandardError => e
+            MiniAPM.logger.debug { "MiniAPM instrumentation error in #{event_name}: #{e.message}" }
+          end
+        end
+
+        def create_span_from_event(event, name:, category:, attributes: {})
+          return unless MiniAPM.enabled?
+          return unless Context.current_trace
+
+          span = Span.new(
+            name: name,
+            category: category,
+            trace_id: Context.current_trace_id,
+            parent_span_id: Context.current_span&.span_id,
+            attributes: attributes
+          )
+
+          # Backfill timing from event
+          if event.time && event.end
+            span.instance_variable_set(:@start_time, (event.time.to_f * 1_000_000_000).to_i)
+            span.instance_variable_set(:@end_time, (event.end.to_f * 1_000_000_000).to_i)
+          else
+            span.finish
+          end
+
+          span
+        end
+
+        def record_span(span)
+          return unless span
+
+          MiniAPM.record_span(span)
+        end
+      end
+    end
+  end
+end

data/lib/miniapm/instrumentations/cache.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    class Cache < Base
+      EVENTS = %w[
+        cache_read.active_support
+        cache_write.active_support
+        cache_delete.active_support
+        cache_exist?.active_support
+        cache_fetch_hit.active_support
+        cache_generate.active_support
+        cache_increment.active_support
+        cache_decrement.active_support
+      ].freeze
+
+      # Minimum duration to record (skip very fast operations)
+      MIN_DURATION_MS = 0.5
+
+      class << self
+        def install!
+          return if installed?
+          mark_installed!
+
+          EVENTS.each do |event_name|
+            subscribe(event_name) do |event|
+              handle_cache_event(event)
+            end
+          end
+        end
+
+        private
+
+        def handle_cache_event(event)
+          return unless MiniAPM.enabled?
+          return unless Context.current_trace
+
+          # Skip very fast cache operations to reduce noise
+          return if event.duration && event.duration < MIN_DURATION_MS
+
+          payload = event.payload
+          operation = event.name.sub("cache_", "").sub(".active_support", "")
+          key = payload[:key]
+
+          attributes = {
+            "cache.operation" => operation,
+            "cache.key" => truncate_key(key)
+          }
+
+          # Add hit/miss info
+          if payload.key?(:hit)
+            attributes["cache.hit"] = payload[:hit]
+          end
+
+          # Add store class if available
+          if payload[:store]
+            attributes["cache.store"] = payload[:store].to_s
+          end
+
+          # Add super_operation for fetch
+          if payload[:super_operation]
+            attributes["cache.super_operation"] = payload[:super_operation].to_s
+          end
+
+          span = create_span_from_event(
+            event,
+            name: "cache #{operation}",
+            category: :cache,
+            attributes: attributes
+          )
+
+          record_span(span)
+        end
+
+        def truncate_key(key)
+          key_str = key.to_s
+          key_str.length > 200 ? key_str[0, 200] + "..." : key_str
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Cache.install!

data/lib/miniapm/instrumentations/http/faraday.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module HTTP
+      class Faraday
+        class << self
+          def install!
+            return if @installed
+            return unless defined?(::Faraday)
+
+            @installed = true
+
+            # Define the middleware class only when Faraday is available
+            define_middleware_class!
+
+            # Register our middleware
+            ::Faraday::Middleware.register_middleware(miniapm: middleware_class)
+
+            # Auto-inject into all connections by patching Connection
+            ::Faraday::Connection.prepend(ConnectionPatch)
+
+            MiniAPM.logger.debug { "MiniAPM: Faraday instrumentation installed" }
+          end
+
+          def installed?
+            @installed || false
+          end
+
+          def middleware_class
+            @middleware_class
+          end
+
+          private
+
+          def define_middleware_class!
+            @middleware_class = Class.new(::Faraday::Middleware) do
+              def call(env)
+                return @app.call(env) unless MiniAPM.enabled?
+                return @app.call(env) unless MiniAPM::Context.current_trace
+
+                uri = env.url
+                http_method = env.method.to_s.upcase
+
+                # Inject trace context
+                MiniAPM::Context.inject_into_headers(env.request_headers)
+
+                span = MiniAPM::Span.new(
+                  name: "#{http_method} #{uri.host}#{uri.path}",
+                  category: :http_client,
+                  trace_id: MiniAPM::Context.current_trace_id,
+                  parent_span_id: MiniAPM::Context.current_span&.span_id,
+                  attributes: {
+                    "http.method" => http_method,
+                    "http.url" => sanitize_url(uri),
+                    "http.host" => uri.host,
+                    "net.peer.name" => uri.host,
+                    "net.peer.port" => uri.port || (uri.scheme == "https" ? 443 : 80)
+                  }
+                )
+
+                MiniAPM::Context.with_span(span) do
+                  begin
+                    response = @app.call(env)
+
+                    span.add_attribute("http.status_code", response.status)
+
+                    if response.status >= 400
+                      span.set_error("HTTP #{response.status}")
+                    else
+                      span.set_ok
+                    end
+
+                    response
+                  rescue StandardError => e
+                    span.record_exception(e)
+                    raise
+                  ensure
+                    span.finish
+                    MiniAPM.record_span(span)
+                  end
+                end
+              end
+
+              private
+
+              def sanitize_url(uri)
+                port = uri.port || (uri.scheme == "https" ? 443 : 80)
+                "#{uri.scheme}://#{uri.host}:#{port}#{uri.path}"
+              end
+            end
+          end
+        end
+
+        # Patch to auto-inject middleware
+        module ConnectionPatch
+          def initialize(url = nil, options = nil, &block)
+            super
+
+            middleware_class = MiniAPM::Instrumentations::HTTP::Faraday.middleware_class
+            # Add our middleware if not already present
+            unless @builder.handlers.any? { |h| h.klass == middleware_class }
+              @builder.insert(0, middleware_class)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Installation is handled by the registry, not auto-install

data/lib/miniapm/instrumentations/http/httparty.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module HTTP
+      class HTTParty
+        class << self
+          def install!
+            return if @installed
+            return unless defined?(::HTTParty)
+
+            @installed = true
+            ::HTTParty::Request.prepend(Patch)
+
+            MiniAPM.logger.debug { "MiniAPM: HTTParty instrumentation installed" }
+          end
+
+          def installed?
+            @installed || false
+          end
+        end
+
+        module Patch
+          def perform(&block)
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            uri = self.uri
+            http_method = self.http_method.name.split("::").last.upcase
+
+            # Inject trace context into outgoing request
+            MiniAPM::Context.inject_into_headers(options[:headers] ||= {})
+
+            span = MiniAPM::Span.new(
+              name: "#{http_method} #{uri.host}#{uri.path}",
+              category: :http_client,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "http.method" => http_method,
+                "http.url" => sanitize_url(uri),
+                "http.host" => uri.host,
+                "net.peer.name" => uri.host,
+                "net.peer.port" => uri.port
+              }
+            )
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                response = super
+
+                if response
+                  span.add_attribute("http.status_code", response.code)
+
+                  if response.code >= 400
+                    span.set_error("HTTP #{response.code}")
+                  else
+                    span.set_ok
+                  end
+                end
+
+                response
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          private
+
+          def sanitize_url(uri)
+            "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+          end
+        end
+      end
+    end
+  end
+end
+
+# Installation is handled by the registry, not auto-install

data/lib/miniapm/instrumentations/http/net_http.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module HTTP
+      class NetHTTP
+        class << self
+          def install!
+            return if @installed
+            return unless defined?(::Net::HTTP)
+
+            @installed = true
+            ::Net::HTTP.prepend(Patch)
+
+            MiniAPM.logger.debug { "MiniAPM: Net::HTTP instrumentation installed" }
+          end
+
+          def installed?
+            @installed || false
+          end
+        end
+
+        module Patch
+          def request(req, body = nil, &block)
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            # Skip if this is MiniAPM's own request
+            return super if req["User-Agent"]&.include?("miniapm-ruby")
+
+            uri = build_uri(req)
+
+            # Inject trace context into outgoing request
+            MiniAPM::Context.inject_into_headers(req)
+
+            span = MiniAPM::Span.new(
+              name: "#{req.method} #{uri.host}#{uri.path}",
+              category: :http_client,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "http.method" => req.method,
+                "http.url" => sanitize_url(uri),
+                "http.host" => uri.host,
+                "net.peer.name" => uri.host,
+                "net.peer.port" => uri.port
+              }
+            )
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                response = super
+
+                span.add_attribute("http.status_code", response.code.to_i)
+                span.add_attribute("http.response_content_length", response["content-length"].to_i) if response["content-length"]
+
+                if response.code.to_i >= 400
+                  span.set_error("HTTP #{response.code}")
+                else
+                  span.set_ok
+                end
+
+                response
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          private
+
+          def build_uri(req)
+            scheme = use_ssl? ? "https" : "http"
+            host = address
+            port_str = (use_ssl? && port == 443) || (!use_ssl? && port == 80) ? "" : ":#{port}"
+
+            path = req.path || "/"
+            path = "/" + path unless path.start_with?("/")
+
+            URI.parse("#{scheme}://#{host}#{port_str}#{path}")
+          rescue StandardError
+            URI.parse("http://#{address}:#{port}#{req.path}")
+          end
+
+          def sanitize_url(uri)
+            # Remove query params for privacy
+            "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+          end
+        end
+      end
+    end
+  end
+end
+
+# Installation is handled by the registry, not auto-install

data/lib/miniapm/instrumentations/rails/controller.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module Rails
+      class Controller < Base
+        class << self
+          def install!
+            return if installed?
+            mark_installed!
+
+            # Subscribe to controller processing
+            subscribe("process_action.action_controller") do |event|
+              handle_process_action(event)
+            end
+
+            # Subscribe to view rendering
+            subscribe("render_template.action_view") do |event|
+              handle_render_template(event)
+            end
+
+            subscribe("render_partial.action_view") do |event|
+              handle_render_partial(event)
+            end
+
+            subscribe("render_collection.action_view") do |event|
+              handle_render_collection(event)
+            end
+
+            subscribe("render_layout.action_view") do |event|
+              handle_render_layout(event)
+            end
+          end
+
+          private
+
+          def handle_process_action(event)
+            span = Context.current_span
+            return unless span&.root?
+
+            payload = event.payload
+
+            # Update root span with controller info
+            span.add_attribute("http.method", payload[:method])
+            span.add_attribute("http.route", "#{payload[:controller]}##{payload[:action]}")
+            span.add_attribute("rails.controller", payload[:controller])
+            span.add_attribute("rails.action", payload[:action])
+            span.add_attribute("rails.format", payload[:format]) if payload[:format]
+
+            if payload[:status]
+              span.add_attribute("http.status_code", payload[:status])
+              span.set_error("HTTP #{payload[:status]}") if payload[:status] >= 500
+            end
+
+            # Add timing breakdown
+            if payload[:db_runtime]
+              span.add_attribute("rails.db_runtime_ms", payload[:db_runtime].round(2))
+            end
+
+            if payload[:view_runtime]
+              span.add_attribute("rails.view_runtime_ms", payload[:view_runtime].round(2))
+            end
+
+            # Record exception if present
+            if payload[:exception_object]
+              span.record_exception(payload[:exception_object])
+            end
+          end
+
+          def handle_render_template(event)
+            record_view_span("render_template", event)
+          end
+
+          def handle_render_partial(event)
+            record_view_span("render_partial", event)
+          end
+
+          def handle_render_collection(event)
+            record_view_span("render_collection", event)
+          end
+
+          def handle_render_layout(event)
+            record_view_span("render_layout", event)
+          end
+
+          def record_view_span(type, event)
+            return unless MiniAPM.enabled?
+            return unless Context.current_trace
+
+            payload = event.payload
+            template = payload[:identifier] || payload[:virtual_path] || "unknown"
+
+            # Clean up template path
+            if defined?(::Rails.root) && ::Rails.root
+              template = template.sub(::Rails.root.to_s + "/", "")
+            end
+
+            template_name = File.basename(template)
+
+            attributes = {
+              "rails.template" => template,
+              "rails.template.type" => type
+            }
+
+            if payload[:layout]
+              attributes["rails.layout"] = payload[:layout]
+            end
+
+            if payload[:count]
+              attributes["rails.collection.count"] = payload[:count]
+            end
+
+            span = create_span_from_event(
+              event,
+              name: "#{type} #{template_name}",
+              category: :view,
+              attributes: attributes
+            )
+
+            record_span(span)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Rails::Controller.install!

data/lib/miniapm/instrumentations/rails/railtie.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module MiniAPM
+  module Instrumentations
+    module Rails
+      class Railtie < ::Rails::Railtie
+        initializer "miniapm.configure_rails_initialization" do |app|
+          # Insert middleware at the beginning of the stack
+          app.middleware.insert(0, MiniAPM::Middleware::Rack)
+          app.middleware.insert(1, MiniAPM::Middleware::ErrorHandler)
+        end
+
+        config.after_initialize do
+          # Auto-detect Rails version
+          MiniAPM.configuration.rails_version ||= ::Rails::VERSION::STRING
+
+          # Auto-detect environment
+          MiniAPM.configuration.environment = ::Rails.env.to_s
+
+          # Disable in test by default unless explicitly enabled
+          if ::Rails.env.test? && ENV["MINI_APM_ENABLED_IN_TEST"].nil?
+            MiniAPM.configuration.enabled = false
+          end
+
+          # Use Rails logger if available
+          if ::Rails.logger && MiniAPM.configuration.auto_start
+            MiniAPM.logger = ::Rails.logger
+          end
+
+          # Start MiniAPM if auto_start is enabled
+          MiniAPM.start! if MiniAPM.configuration.auto_start
+        end
+      end
+    end
+  end
+end
+
+# Require middleware
+require_relative "../../middleware/rack"
+require_relative "../../middleware/error_handler"