miniapm 1.0.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 525eb11f5af8c0b35aedcb05f67523d4f390c56af7fd3fd1dc3169ad1f934967
-  data.tar.gz: '09aa0e5d42736b39c895174cdddc9aec4944de4168beae335c6e335b212fb3ba'
+  metadata.gz: c449015f1ca45ec37a611645ce5e220f33eb59cfcc2e1d5d33a703ee5acd37b7
+  data.tar.gz: 415f6d83da9ef99c12b104ac5c23265585c47758176894734622903ed327ad60
 SHA512:
-  metadata.gz: bfd98917e4502be3f040ade6c9b5e1666d3a0e1f05d99cda07be033eee5f82d99e8e5584906d6e09514b01c2e8dd22d4ed9e6e76beab24cd16240d4a1d9e321d
-  data.tar.gz: 9b8f7707deb4cd5c3a941c87c5416a64188527fe19c605c3fdc37a27f1ac3df44cf0a6de3c5acc72f4ef0fe67bb870e711418ac28ded78c726fff9538a8077ac
+  metadata.gz: 6de6e509faec967f0da90e233823b6ecf325a5f4e3b6d3d248569906f9310fcd07718cb3af3795bf9b454315b1f3c131fcf66031d12c6f8135c4a478fa08ae3d
+  data.tar.gz: 2a82ad3cab7be447ed2be3531eb862c0803ba1757bd34a7fd0f2d2874fd4d8e23e16a90f8a974460fa79232bde8327e5d91048f0410f8208f3214743dd1f63b5

data/lib/miniapm/configuration.rb

@@ -138,7 +138,7 @@ module MiniAPM
   class InstrumentationConfig
     DEFAULTS = {
       rails: { enabled: true },
-      activerecord: { enabled: true, log_sql: false },
+      activerecord: { enabled: true, log_sql: true },
       activejob: { enabled: true },
       sidekiq: { enabled: true },
       cache: { enabled: true },

data/lib/miniapm/error_event.rb

@@ -7,7 +7,10 @@ module MiniAPM
   class ErrorEvent
     attr_reader :exception_class, :message, :backtrace, :fingerprint
     attr_reader :request_id, :user_id, :params, :timestamp
-    attr_reader :context
+    attr_reader :context, :source_context
+
+    # Number of lines to include before and after the error line
+    CONTEXT_LINES = 5
 
     def initialize(
       exception_class:,
@@ -29,6 +32,7 @@ module MiniAPM
       @params = filter_params(params)
       @timestamp = timestamp || Time.now.utc
       @context = context
+      @source_context = extract_source_context
     end
 
     def self.from_exception(exception, context = {})
@@ -44,7 +48,7 @@ module MiniAPM
     end
 
     def to_h
-      {
+      hash = {
         exception_class: @exception_class,
         message: @message,
         backtrace: @backtrace,
@@ -53,7 +57,9 @@ module MiniAPM
         user_id: @user_id,
         params: @params,
         timestamp: @timestamp.iso8601
-      }.compact
+      }
+      hash[:source_context] = @source_context if @source_context
+      hash.compact
     end
 
     private
@@ -126,5 +132,60 @@ module MiniAPM
       string = string.to_s
       string.length > max_length ? string[0, max_length] + "..." : string
     end
+
+    def extract_source_context
+      # Find first application backtrace line (not gem/stdlib)
+      app_line = @backtrace.find do |line|
+        !line.include?("/gems/") &&
+        !line.include?("/ruby/") &&
+        !line.include?("/vendor/") &&
+        !line.include?("/bundle/") &&
+        !line.start_with?("<")
+      end
+
+      return nil unless app_line
+
+      # Parse file:line from backtrace line
+      # Format: "/path/to/file.rb:123:in `method_name'" or "/path/to/file.rb:123"
+      match = app_line.match(/\A(.+?):(\d+)/)
+      return nil unless match
+
+      file_path = match[1]
+      lineno = match[2].to_i
+
+      # Handle relative paths (e.g., "app/controllers/...") by prepending Rails.root
+      unless file_path.start_with?("/")
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          file_path = File.join(Rails.root.to_s, file_path)
+        else
+          return nil
+        end
+      end
+
+      return nil unless File.exist?(file_path) && File.readable?(file_path)
+
+      begin
+        lines = File.readlines(file_path)
+        return nil if lineno < 1 || lineno > lines.length
+
+        # Calculate context range (0-indexed)
+        start_line = [lineno - CONTEXT_LINES - 1, 0].max
+        end_line = [lineno + CONTEXT_LINES - 1, lines.length - 1].min
+
+        pre_context = lines[start_line...lineno - 1].map(&:chomp)
+        context_line = lines[lineno - 1]&.chomp || ""
+        post_context = lines[lineno..end_line].map(&:chomp)
+
+        {
+          file: file_path,
+          lineno: lineno,
+          pre_context: pre_context,
+          context_line: context_line,
+          post_context: post_context
+        }
+      rescue StandardError
+        nil
+      end
+    end
   end
 end

data/lib/miniapm/instrumentations/activerecord.rb

@@ -43,7 +43,7 @@ module MiniAPM
 
           attributes["db.sql.table"] = table if table
 
-          # Optionally log SQL (configurable, defaults to off)
+          # Log SQL (configurable, defaults to on)
           if MiniAPM.configuration.instrumentations.options(:activerecord)[:log_sql]
             attributes["db.statement"] = truncate_sql(sql)
           end

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

@@ -4,32 +4,88 @@ module MiniAPM
   module Instrumentations
     module Rails
       class Controller < Base
+        # Subscriber class for view rendering that tracks span context properly
+        class ViewSubscriber
+          def initialize(type)
+            @type = type
+            @spans = {}
+          end
+
+          def start(name, id, payload)
+            return unless MiniAPM.enabled?
+            return unless Context.current_trace
+
+            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
+            }
+
+            attributes["rails.layout"] = payload[:layout] if payload[:layout]
+            attributes["rails.collection.count"] = payload[:count] if payload[:count]
+
+            span = Span.new(
+              name: "#{@type} #{template_name}",
+              category: :view,
+              trace_id: Context.current_trace_id,
+              parent_span_id: Context.current_span&.span_id,
+              attributes: attributes
+            )
+
+            # Store span by event ID and push to context
+            @spans[id] = span
+            Context.push_span(span)
+          end
+
+          def finish(name, id, payload)
+            span = @spans.delete(id)
+            return unless span
+
+            # Pop from context and finish
+            Context.pop_span
+            span.finish
+            MiniAPM.record_span(span)
+          end
+        end
+
         class << self
           def install!
             return if installed?
             mark_installed!
 
-            # Subscribe to controller processing
+            # Subscribe to controller processing (still uses standard subscribe)
             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 to view rendering with monotonic subscribers for proper nesting
+            ActiveSupport::Notifications.monotonic_subscribe(
+              "render_template.action_view",
+              ViewSubscriber.new("render_template")
+            )
 
-            subscribe("render_partial.action_view") do |event|
-              handle_render_partial(event)
-            end
+            ActiveSupport::Notifications.monotonic_subscribe(
+              "render_partial.action_view",
+              ViewSubscriber.new("render_partial")
+            )
 
-            subscribe("render_collection.action_view") do |event|
-              handle_render_collection(event)
-            end
+            ActiveSupport::Notifications.monotonic_subscribe(
+              "render_collection.action_view",
+              ViewSubscriber.new("render_collection")
+            )
 
-            subscribe("render_layout.action_view") do |event|
-              handle_render_layout(event)
-            end
+            ActiveSupport::Notifications.monotonic_subscribe(
+              "render_layout.action_view",
+              ViewSubscriber.new("render_layout")
+            )
           end
 
           private
@@ -64,60 +120,16 @@ module MiniAPM
             # 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 + "/", "")
+              # Also send to dedicated errors endpoint (with source context)
+              MiniAPM.record_error(
+                payload[:exception_object],
+                context: {
+                  request_id: payload[:request]&.request_id,
+                  params: payload[:params]
+                }
+              )
             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

data/lib/miniapm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniAPM
-  VERSION = "1.0.0"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: miniapm
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Chris Hasinski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-03 00:00:00.000000000 Z
+date: 2026-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake