closeyourit-ruby 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82202d393845e74a379b6470a2f5f1c9e093d70840669266fb86624edd326c48
-  data.tar.gz: 7a302acfe53c9e0eb866ba407e9133bb63681c3d365126abdbf55368527ab7e4
+  metadata.gz: fce4d4eb3a92009bf70daeb903091ec30b4274d926b52d5b8df44644a808c35e
+  data.tar.gz: be83377677c8567c700d8ba5d6a47aa1664474db87aa750ab8a61dbed85fadb2
 SHA512:
-  metadata.gz: b85ebd77af24ee4aaa41ab447ba434be2ac3892c0ba4c7b09cf5a39069aca91ddb649a179ef621d72c263449452dcb5942c82df5449cd17e37a3494c374b8ed0
-  data.tar.gz: 037b9982aad55978b4c124d0751da800983327d18d8786228d8bbd00233f913a0e6ef8dd7e741c06307f11ed425ba2e37b8eae9dc985fba7c2067a9cbafda7fa
+  metadata.gz: 4533f36e714d2c8ac1706a8bdce8652beed02384f0ce09f5965679c0d76a5e098b5ed006530bc88bbc4c92ed982ed373bd9dd5d5db04cf015770949deebe3e00
+  data.tar.gz: 3500e6f71ea42ba8bb900d78dabde73941913e5b03459ab0f2e570b27c26b6637df27a786d5ea1eb6e63b7ffcb8c8b84d07b6299d5553d5711ea3700543449dd

data/lib/closeyourit/configuration.rb

@@ -24,7 +24,10 @@ module CloseYourIt
                   :breadcrumbs_enabled, :max_breadcrumbs, :sample_rate,
                   :capture_handled_errors, :report_active_job_errors,
                   :logs_enabled, :logs_sample_rate, :logs_batch_size, :logs_flush_interval,
-                  :capture_rails_logs, :logs_min_level
+                  :capture_rails_logs, :logs_min_level,
+                  :detect_performance_issues, :n_plus_one_threshold, :query_count_threshold,
+                  :query_time_threshold_ms, :slow_request_threshold_ms, :slow_external_threshold_ms,
+                  :capture_external_http
     attr_writer :release
     attr_reader :excluded_exceptions, :filter_parameters, :scrub_message_patterns
 
@@ -76,6 +79,17 @@ module CloseYourIt
       @capture_rails_logs = false
       @logs_min_level     = :info
 
+      # Performance issue detection (verdetti aggregati: N+1, slow request, HTTP esterne lente).
+      # OPT-IN, default OFF: profila OGNI query della richiesta → overhead non trascurabile, va attivato
+      # consapevolmente per-app. Le soglie sono conservative (poco rumore). Vedi Performance::Rollup.
+      @detect_performance_issues = false
+      @n_plus_one_threshold      = 10        # stesso fingerprint+call-site eseguito > N volte in una richiesta
+      @query_count_threshold     = 100       # troppe query totali in una richiesta
+      @query_time_threshold_ms   = 500       # tempo DB totale per richiesta oltre cui = high_query_count
+      @slow_request_threshold_ms = 1000      # durata totale della richiesta
+      @slow_external_threshold_ms = 1000     # singola chiamata HTTP esterna
+      @capture_external_http     = true      # strumenta Net::HTTP (solo se detect_performance_issues)
+
       @filter_parameters      = []
       @scrub_message_patterns = []
     end

data/lib/closeyourit/events/performance_issue_event.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../event"
+
+module CloseYourIt
+  # Payload `kind=performance_issue` per la pipeline metriche (`/api/v1/projects/:id/metrics`).
+  # È un VERDETTO aggregato (N+1, slow request, slow external HTTP), non una metrica grezza:
+  # `subtype` lo qualifica, `trace_id` lo correla a log/errori della stessa richiesta. Lo SQL è già
+  # offuscato (è il fingerprint del profilo). I campi nil vengono omessi (slow_request non ha sql).
+  class PerformanceIssueEvent < Event
+    def initialize(attrs, configuration)
+      super(configuration)
+      @attrs = attrs
+    end
+
+    def to_h
+      compact(
+        "kind" => "performance_issue",
+        "subtype" => @attrs[:subtype],
+        "sample_id" => SecureRandom.uuid,
+        "duration_ms" => @attrs[:duration_ms]&.round(2),
+        "occurred_at" => @occurred_at,
+        "environment" => environment,
+        "trace_id" => @attrs[:trace_id],
+        "sql" => @attrs[:sql],
+        "source" => @attrs[:source],
+        "route" => @attrs[:route],
+        "http_host" => @attrs[:http_host],
+        "http_url" => @attrs[:http_url],
+        "query_count" => @attrs[:query_count],
+        "total_query_time_ms" => @attrs[:total_query_time_ms]&.round(2),
+        "count_in_request" => @attrs[:count_in_request],
+        "sdk" => sdk
+      )
+    end
+
+    def ingest_path(project_id)
+      "/api/v1/projects/#{project_id}/metrics"
+    end
+  end
+end

data/lib/closeyourit/events/slow_query_event.rb

@@ -3,6 +3,7 @@
 require "securerandom"
 require_relative "../event"
 require_relative "../scrubber"
+require_relative "../scope"
 
 module CloseYourIt
   # Payload `kind=slow_query` per la pipeline metriche (`/api/v1/projects/:id/metrics`).
@@ -27,6 +28,7 @@ module CloseYourIt
         "cached" => @payload.fetch(:cached, false),
         "db_system" => db_system,
         "source" => @payload[:source],
+        "trace_id" => CloseYourIt::Scope.current.trace_id,
         "bindings" => bindings,
         "sdk" => sdk
       )

data/lib/closeyourit/performance/request_profile.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module Performance
+    # Accumulatore per-richiesta (vive nello Scope, resettato a fine richiesta). Conta le query, le
+    # raggruppa per [fingerprint SQL offuscato, call-site] (il pattern prosopite per l'N+1) e tiene le
+    # chiamate HTTP esterne. Puro stato in memoria: il verdetto lo calcola Performance::Rollup.
+    class RequestProfile
+      # Guard di memoria: cap ai gruppi/chiamate distinti tracciati (il conteggio totale resta esatto).
+      MAX_GROUPS = 1000
+      MAX_EXTERNAL = 500
+
+      attr_reader :query_count, :total_query_time_ms, :query_groups, :external_calls
+
+      def initialize
+        @query_count = 0
+        @total_query_time_ms = 0.0
+        @query_groups = {}
+        @external_calls = []
+      end
+
+      # Una query non di sistema. Le query da cache non sono round-trip DB → non contano per l'N+1.
+      def add_query(fingerprint:, source:, duration_ms:, cached: false)
+        return if cached
+
+        ms = duration_ms.to_f
+        @query_count += 1
+        @total_query_time_ms += ms
+
+        key = "#{fingerprint}\n#{source}"
+        group = @query_groups[key]
+        if group
+          group[:count] += 1
+          group[:duration_ms] += ms
+        elsif @query_groups.size < MAX_GROUPS
+          @query_groups[key] = { count: 1, duration_ms: ms, sql: fingerprint, source: source }
+        end
+      end
+
+      def add_external(host:, path:, duration_ms:)
+        return if @external_calls.size >= MAX_EXTERNAL
+
+        @external_calls << { host: host, path: path, duration_ms: duration_ms.to_f }
+      end
+
+      def empty?
+        @query_count.zero? && @external_calls.empty?
+      end
+    end
+  end
+end

data/lib/closeyourit/performance/rollup.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../events/performance_issue_event"
+
+module CloseYourIt
+  module Performance
+    # Trasforma un RequestProfile (+ durata/route della richiesta) in 0..N verdetti PerformanceIssueEvent.
+    # Le soglie vivono nella Configuration. Detection lato client; dedup/alert lato backend.
+    class Rollup
+      def self.call(...) = new(...).call
+
+      def initialize(profile:, configuration:, route: nil, request_duration_ms: nil, trace_id: nil)
+        @profile = profile
+        @config = configuration
+        @route = route
+        @request_duration_ms = request_duration_ms
+        @trace_id = trace_id
+      end
+
+      def call
+        events = []
+        events.concat(n_plus_one_events)
+        events << high_query_count_event if high_query_count?
+        events << slow_request_event if slow_request?
+        events.concat(slow_external_events)
+        events.compact
+      end
+
+      private
+
+      # Un verdetto per ogni gruppo [fingerprint, call-site] che ha girato più di n_plus_one_threshold volte.
+      def n_plus_one_events
+        @profile.query_groups.values.filter_map do |group|
+          next unless group[:count] > @config.n_plus_one_threshold
+
+          build(subtype: "n_plus_one", duration_ms: group[:duration_ms], sql: group[:sql],
+                source: group[:source], query_count: group[:count], count_in_request: group[:count])
+        end
+      end
+
+      def high_query_count?
+        (@config.query_count_threshold && @profile.query_count > @config.query_count_threshold) ||
+          (@config.query_time_threshold_ms && @profile.total_query_time_ms > @config.query_time_threshold_ms)
+      end
+
+      def high_query_count_event
+        build(subtype: "high_query_count", duration_ms: @profile.total_query_time_ms,
+              query_count: @profile.query_count, total_query_time_ms: @profile.total_query_time_ms,
+              route: @route)
+      end
+
+      def slow_request?
+        @request_duration_ms && @config.slow_request_threshold_ms &&
+          @request_duration_ms > @config.slow_request_threshold_ms
+      end
+
+      def slow_request_event
+        build(subtype: "slow_request", duration_ms: @request_duration_ms, route: @route,
+              query_count: @profile.query_count, total_query_time_ms: @profile.total_query_time_ms)
+      end
+
+      def slow_external_events
+        @profile.external_calls.filter_map do |call|
+          next unless call[:duration_ms] > @config.slow_external_threshold_ms
+
+          build(subtype: "slow_external_http", duration_ms: call[:duration_ms],
+                http_host: call[:host], http_url: call[:path])
+        end
+      end
+
+      def build(attrs)
+        PerformanceIssueEvent.new(attrs.merge(trace_id: @trace_id), @config)
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/net_http_patch.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "../scope"
+
+module CloseYourIt
+  module Rails
+    # Prepended a Net::HTTP: cronometra ogni chiamata esterna e la spinge nel RequestProfile dello
+    # Scope, così la finestra della richiesta può rilevare le HTTP esterne lente. Trasparente
+    # (restituisce la risposta originale) e difensivo (no-op se la telemetria è off; mai solleva per
+    # colpa del profiling). Esclude le chiamate verso l'endpoint CloseYourIt stesso (niente loop).
+    module NetHTTPPatch
+      def request(req, body = nil, &block)
+        config = CloseYourIt.configuration
+        return super unless config.detect_performance_issues && config.capture_external_http
+
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          super
+        ensure
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0
+          record_external(config, req, duration_ms)
+        end
+      end
+
+      private
+
+      def record_external(config, req, duration_ms)
+        host = address
+        return if host.nil? || own_endpoint?(config, host)
+
+        CloseYourIt::Scope.current.performance_profile.add_external(
+          host: host, path: templatize_path(req), duration_ms: duration_ms
+        )
+      rescue StandardError
+        # Il profiling non deve mai disturbare la chiamata ospite.
+        nil
+      end
+
+      def own_endpoint?(config, host)
+        endpoint = config.endpoint_url
+        return false if endpoint.nil?
+
+        URI.parse(endpoint).host == host
+      rescue URI::InvalidURIError
+        false
+      end
+
+      # Path senza query string, con uuid e run di ≥3 cifre → placeholder (stessa rotta = stessa
+      # signature). La soglia ≥3 cifre preserva le versioni API tipo "/v1" e templatizza gli id reali
+      # ("/v1/charges/ch_12345" → "/v1/charges/ch_<n>", "/users/123" → "/users/<n>").
+      def templatize_path(req)
+        path = req.respond_to?(:path) ? req.path.to_s : ""
+        path.split("?", 2).first.to_s
+            .gsub(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i, "<uuid>")
+            .gsub(/\d{3,}/, "<n>")
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/railtie.rb

@@ -7,7 +7,9 @@ require_relative "error_subscriber"
 require_relative "../sidekiq/error_handler"
 require_relative "query_source"
 require_relative "log_broadcast"
+require_relative "net_http_patch"
 require_relative "../subscribers/slow_query"
+require_relative "../subscribers/request_performance"
 
 module CloseYourIt
   module Rails
@@ -45,9 +47,39 @@ module CloseYourIt
             duration_ms: event.duration,
             cached: event.payload.fetch(:cached, false)
           )
+          # Accumula la query nel profilo per-richiesta (detection N+1 a fine richiesta).
+          subscriber.profile(
+            name: event.payload[:name],
+            sql: event.payload[:sql],
+            duration_ms: event.duration,
+            cached: event.payload.fetch(:cached, false),
+            source: CloseYourIt::Rails::QuerySource.from_caller
+          )
+        end
+      end
+
+      # A fine richiesta: trasforma il profilo accumulato in verdetti performance_issue (N+1, slow
+      # request, HTTP esterne lente). Il subscriber è no-op se detect_performance_issues è OFF.
+      initializer "closeyourit.subscribe_request_performance" do
+        perf = CloseYourIt::Subscribers::RequestPerformance.new
+
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          payload = event.payload
+          perf.record(
+            route: "#{payload[:controller]}##{payload[:action]}",
+            duration_ms: event.duration
+          )
         end
       end
 
+      # Strumenta le chiamate HTTP esterne (Net::HTTP) per rilevare quelle lente nella finestra della
+      # richiesta. Il patch è no-op (chiama super) se la detection è OFF → overhead trascurabile.
+      initializer "closeyourit.instrument_net_http" do
+        require "net/http"
+        ::Net::HTTP.prepend(CloseYourIt::Rails::NetHTTPPatch) unless ::Net::HTTP.ancestors.include?(CloseYourIt::Rails::NetHTTPPatch)
+      end
+
       # Cattura gli errori di ActiveJob/Solid Queue (around_perform).
       initializer "closeyourit.active_job" do
         ActiveSupport.on_load(:active_job) do
@@ -64,7 +96,11 @@ module CloseYourIt
 
       # Broadcast opt-in di Rails.logger → CloseYourIt.log (config.capture_rails_logs, default OFF).
       # Spedisce solo i log dell'app ≥ logs_min_level. Richiede BroadcastLogger (Rails 7.1+).
-      initializer "closeyourit.capture_rails_logs" do
+      # `after: :load_config_initializers`: config.capture_rails_logs è impostato in
+      # config/initializers/closeyourit.rb (CloseYourIt.init), che gira DOPO gli initializer dei
+      # railtie. Senza questo `after:` il check leggerebbe il default (false) e il broadcast non
+      # verrebbe mai agganciato → i log dell'app non arriverebbero a CloseYourIt.
+      initializer "closeyourit.capture_rails_logs", after: :load_config_initializers do
         config = CloseYourIt.configuration
         if config.capture_rails_logs && ::Rails.logger.respond_to?(:broadcast_to)
           ::Rails.logger.broadcast_to(CloseYourIt::Rails::LogBroadcast.new(config.logs_min_level))

data/lib/closeyourit/scope.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "breadcrumb_buffer"
+require_relative "performance/request_profile"
 
 module CloseYourIt
   # Contesto per-richiesta (o per-job) isolato per execution-context (Fiber storage):
@@ -65,6 +66,12 @@ module CloseYourIt
       @breadcrumbs.add(breadcrumb)
     end
 
+    # Profilo di performance per-richiesta (query + HTTP esterne). Lazy: creato al primo accesso,
+    # azzerato da #clear a fine richiesta. Il verdetto lo calcola Subscribers::RequestPerformance.
+    def performance_profile
+      @performance_profile ||= Performance::RequestProfile.new
+    end
+
     def clear
       @user        = {}
       @tags        = {}
@@ -73,6 +80,7 @@ module CloseYourIt
       @request     = nil
       @trace_id    = nil
       @breadcrumbs = BreadcrumbBuffer.new(CloseYourIt.configuration.max_breadcrumbs)
+      @performance_profile = nil
     end
 
     # Sottoinsieme non vuoto in forma evento Sentry (user/tags/extra/contexts/request),

data/lib/closeyourit/subscribers/request_performance.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../scope"
+require_relative "../performance/rollup"
+
+module CloseYourIt
+  module Subscribers
+    # A fine richiesta (process_action.action_controller) trasforma il RequestProfile accumulato nello
+    # Scope in verdetti performance_issue e li spedisce (fire-and-forget). Lo Scope — e quindi il
+    # profilo — viene azzerato subito dopo da RequestContext#call (ensure). Logica pura: il wiring ad
+    # ActiveSupport::Notifications vive nel Railtie.
+    class RequestPerformance
+      def initialize(configuration = nil)
+        @configuration = configuration
+      end
+
+      def record(route:, duration_ms:)
+        config = @configuration || CloseYourIt.configuration
+        return unless config.detect_performance_issues
+
+        profile = CloseYourIt::Scope.current.performance_profile
+        return if profile.empty? && !slow_request?(config, duration_ms)
+
+        events = CloseYourIt::Performance::Rollup.call(
+          profile: profile, configuration: config, route: route,
+          request_duration_ms: duration_ms, trace_id: CloseYourIt::Scope.current.trace_id
+        )
+        events.each { |event| CloseYourIt.capture_event(event) }
+      end
+
+      private
+
+      def slow_request?(config, duration_ms)
+        duration_ms && config.slow_request_threshold_ms && duration_ms > config.slow_request_threshold_ms
+      end
+    end
+  end
+end

data/lib/closeyourit/subscribers/slow_query.rb

@@ -2,6 +2,7 @@
 
 require_relative "../events/slow_query_event"
 require_relative "../scrubber"
+require_relative "../scope"
 
 module CloseYourIt
   module Subscribers
@@ -40,13 +41,33 @@ module CloseYourIt
         CloseYourIt.add_breadcrumb(
           category: "query",
           type: "query",
-          message: Scrubber.new(config).obfuscate_sql(sql),
+          message: scrubber(config).obfuscate_sql(sql),
           data: { "name" => name, "duration_ms" => duration_ms.to_f.round(2), "cached" => cached }
         )
       end
 
+      # Spinge OGNI query non di sistema nel RequestProfile dello Scope (per la detection N+1 a fine
+      # richiesta). Solo se detect_performance_issues: fingerprint = SQL offuscato + call-site.
+      def profile(name:, sql:, duration_ms:, cached: false, source: nil)
+        config = @configuration || CloseYourIt.configuration
+        return unless config.detect_performance_issues
+        return if ignored_name?(name)
+
+        CloseYourIt::Scope.current.performance_profile.add_query(
+          fingerprint: scrubber(config).obfuscate_sql(sql),
+          source: source, duration_ms: duration_ms, cached: cached
+        )
+      rescue StandardError
+        # La telemetria non deve mai disturbare la query ospite.
+        nil
+      end
+
       private
 
+      def scrubber(config)
+        @scrubber ||= Scrubber.new(config)
+      end
+
       def ignored_name?(name)
         name.nil? || IGNORED_NAMES.include?(name)
       end

data/lib/closeyourit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloseYourIt
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/lib/closeyourit-ruby.rb

@@ -16,15 +16,20 @@ require_relative "closeyourit/events/message_event"
 require_relative "closeyourit/events/slow_query_event"
 require_relative "closeyourit/events/slow_method_event"
 require_relative "closeyourit/events/log_event"
+require_relative "closeyourit/events/performance_issue_event"
+require_relative "closeyourit/performance/request_profile"
+require_relative "closeyourit/performance/rollup"
 require_relative "closeyourit/log_device"
 require_relative "closeyourit/log_buffer"
 require_relative "closeyourit/subscribers/slow_query"
+require_relative "closeyourit/subscribers/request_performance"
 require_relative "closeyourit/instrumenter"
 require_relative "closeyourit/monitor"
 require_relative "closeyourit/client"
 require_relative "closeyourit/rails/capture_exceptions"
 require_relative "closeyourit/rails/request_context"
 require_relative "closeyourit/rails/log_broadcast"
+require_relative "closeyourit/rails/net_http_patch"
 require_relative "closeyourit/rails/active_job_extension"
 require_relative "closeyourit/rails/error_subscriber"
 require_relative "closeyourit/sidekiq/error_handler"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closeyourit-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Alessio Bussolari
@@ -43,16 +43,20 @@ files:
 - lib/closeyourit/events/error_event.rb
 - lib/closeyourit/events/log_event.rb
 - lib/closeyourit/events/message_event.rb
+- lib/closeyourit/events/performance_issue_event.rb
 - lib/closeyourit/events/slow_method_event.rb
 - lib/closeyourit/events/slow_query_event.rb
 - lib/closeyourit/instrumenter.rb
 - lib/closeyourit/log_buffer.rb
 - lib/closeyourit/log_device.rb
 - lib/closeyourit/monitor.rb
+- lib/closeyourit/performance/request_profile.rb
+- lib/closeyourit/performance/rollup.rb
 - lib/closeyourit/rails/active_job_extension.rb
 - lib/closeyourit/rails/capture_exceptions.rb
 - lib/closeyourit/rails/error_subscriber.rb
 - lib/closeyourit/rails/log_broadcast.rb
+- lib/closeyourit/rails/net_http_patch.rb
 - lib/closeyourit/rails/query_source.rb
 - lib/closeyourit/rails/railtie.rb
 - lib/closeyourit/rails/request_context.rb
@@ -60,6 +64,7 @@ files:
 - lib/closeyourit/scrubber.rb
 - lib/closeyourit/sidekiq/error_handler.rb
 - lib/closeyourit/stats.rb
+- lib/closeyourit/subscribers/request_performance.rb
 - lib/closeyourit/subscribers/slow_query.rb
 - lib/closeyourit/transport.rb
 - lib/closeyourit/version.rb