closeyourit-ruby 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82202d393845e74a379b6470a2f5f1c9e093d70840669266fb86624edd326c48
-  data.tar.gz: 7a302acfe53c9e0eb866ba407e9133bb63681c3d365126abdbf55368527ab7e4
+  metadata.gz: f8d2868773842804dc2c90f163ea4766ea748c59edf8adaa956f257827391e8c
+  data.tar.gz: 7fe183c1a6c64226f341b09c7da4cd37bf58bb75409b9afc20c223efc55ffe1f
 SHA512:
-  metadata.gz: b85ebd77af24ee4aaa41ab447ba434be2ac3892c0ba4c7b09cf5a39069aca91ddb649a179ef621d72c263449452dcb5942c82df5449cd17e37a3494c374b8ed0
-  data.tar.gz: 037b9982aad55978b4c124d0751da800983327d18d8786228d8bbd00233f913a0e6ef8dd7e741c06307f11ed425ba2e37b8eae9dc985fba7c2067a9cbafda7fa
+  metadata.gz: fc0267a4f038cd2ab3f6e0af119cacbdb368cdce3f4d07d2a01ea1b8b5f2d2c4f4753fed6d5dcc0b71c5826868c7557eab614d7b0f37f953fd586aff01147c1b
+  data.tar.gz: 0b6e57599d21d07d4d2552331aa14d17bed514c7ed0733881d4a7ebd850051ca1271137fac7147f1e2d12c74c69e6e5e265017b256c36abf06ffd6342b458350

data/README.md

@@ -26,12 +26,12 @@ Caratteristiche:
 
 ## Installazione
 
-Uso interno → install via git o path (no RubyGems):
+Pubblicata su [RubyGems](https://rubygems.org/gems/closeyourit-ruby):
 
 ```ruby
 # Gemfile del progetto da monitorare
-gem "closeyourit-ruby", git: "https://github.com/bussolabs/closeyourit-ruby"
-# in sviluppo locale:
+gem "closeyourit-ruby"
+# in sviluppo locale, dal checkout:
 # gem "closeyourit-ruby", path: "../closeyourit-ruby"
 ```
 

data/lib/closeyourit/configuration.rb

@@ -20,11 +20,15 @@ module CloseYourIt
                   :slow_query_threshold_ms, :slow_method_threshold_ms,
                   :send_pii, :obfuscate_sql, :send_server_name,
                   :capture_query_bindings, :capture_method_arguments,
-                  :capture_request, :request_header_allowlist,
+                  :capture_request, :request_header_allowlist, :context_lines,
+                  :capture_request_body,
                   :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
 
@@ -52,6 +56,14 @@ module CloseYourIt
       @capture_request          = true
       @request_header_allowlist = DEFAULT_REQUEST_HEADER_ALLOWLIST.dup
 
+      # Righe di sorgente attorno a ogni frame dello stacktrace (pre/context/post). 0 = disattivo.
+      @context_lines = 3
+
+      # Params del body della richiesta nell'evento (`request.data`), estratti LAZY solo quando
+      # l'errore accade, sanitizzati e scrubbati (denylist + filter_parameters). Il backend
+      # ri-scruba difensivamente. Upload → placeholder, cap 64 KB.
+      @capture_request_body = true
+
       # Breadcrumbs: cronologia (query offuscate, eventi custom) allegata all'errore.
       @breadcrumbs_enabled = true
       @max_breadcrumbs     = 100
@@ -76,6 +88,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/error_event.rb

@@ -4,6 +4,7 @@ require "securerandom"
 require "socket"
 require_relative "../event"
 require_relative "../scrubber"
+require_relative "../line_cache"
 
 module CloseYourIt
   # Trasforma un'eccezione Ruby nel **payload evento Sentry** che il backend CloseYourIt ingerisce
@@ -72,21 +73,35 @@ module CloseYourIt
       }
     end
 
-    # Sentry-style: frame più recente per ultimo; chiavi filename/function/lineno/in_app/abs_path.
+    # Sentry-style: frame più recente per ultimo; chiavi filename/function/lineno/in_app/abs_path
+    # + snippet di sorgente (pre_context/context_line/post_context) quando il file è leggibile.
     def frames(locations)
       return [] if locations.nil?
 
+      context_lines = @configuration.context_lines.to_i
       locations.reverse.map do |loc|
-        {
+        frame = {
           "filename" => loc.path,
           "abs_path" => loc.path,
           "function" => loc.label,
           "lineno" => loc.lineno,
           "in_app" => in_app?(loc.path)
         }
+        add_context!(frame, loc.path, loc.lineno, context_lines) if context_lines.positive?
+        frame
       end
     end
 
+    def add_context!(frame, path, lineno, count)
+      lines = LineCache.lines(path)
+      return if lines.nil? || lineno.nil? || lineno < 1 || lineno > lines.size
+
+      index = lineno - 1
+      frame["pre_context"]  = lines[[ index - count, 0 ].max...index]
+      frame["context_line"] = lines[index]
+      frame["post_context"] = lines[index + 1, count] || []
+    end
+
     def in_app?(path)
       return false if path.nil?
 

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/line_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  # Cache in-process delle righe dei file sorgente, per le context lines dei frame
+  # (pre_context/context_line/post_context). Bounded: oltre MAX_FILES si svuota per intero —
+  # semplice e sufficiente (i file di un'app in errore sono pochi e ricorrenti). Thread-safe.
+  module LineCache
+    MAX_FILES = 200
+
+    @cache = {}
+    @mutex = Mutex.new
+
+    class << self
+      # Righe del file (chomp-ate), oppure nil se non leggibile o path sintetico ("(eval)", "(irb)").
+      def lines(path)
+        return nil if path.nil? || path.empty? || path.start_with?("(")
+
+        @mutex.synchronize do
+          return @cache[path] if @cache.key?(path)
+
+          @cache.clear if @cache.size >= MAX_FILES
+          @cache[path] = read_lines(path)
+        end
+      end
+
+      def clear
+        @mutex.synchronize { @cache.clear }
+      end
+
+      private
+
+      def read_lines(path)
+        return nil unless File.readable?(path)
+
+        File.readlines(path, chomp: true)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

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/rails/request_body.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require_relative "../scrubber"
+
+module CloseYourIt
+  module Rails
+    # Estrae i params del body della richiesta (`request.data`) al momento dell'EVENTO — mai
+    # eagerly a ogni richiesta (zero overhead sul percorso felice). Preferisce i params già
+    # parsati da Rails/Rack presenti in env; ripiega sulla rilettura di rack.input (con rewind)
+    # solo per JSON/form ≤ MAX_BODY_BYTES. Output sanitizzato (upload → "[FILE: …]", oggetti →
+    # "[OBJECT: …]", stringhe troncate) e scrubbato con la stessa denylist del resto del client.
+    module RequestBody
+      MAX_BODY_BYTES = 65_536
+      MAX_DEPTH = 8
+      MAX_STRING = 1024
+
+      FORM_TYPE = "application/x-www-form-urlencoded"
+      JSON_TYPE = "application/json"
+
+      class << self
+        def extract(env)
+          params = parsed_params(env) || raw_params(env)
+          return nil if params.nil? || params.empty?
+
+          Scrubber.new(CloseYourIt.configuration).filter_params(sanitize(params, 0))
+        rescue StandardError
+          nil
+        end
+
+        private
+
+        # Params già parsati a monte (ActionDispatch o Rack): nessuna rilettura del body.
+        def parsed_params(env)
+          env["action_dispatch.request.request_parameters"] || env["rack.request.form_hash"]
+        end
+
+        def raw_params(env)
+          raw = read_body(env)
+          return nil if raw.nil? || raw.empty?
+
+          case env["CONTENT_TYPE"].to_s.split(";").first.to_s.strip.downcase
+          when JSON_TYPE
+            value = JSON.parse(raw)
+            value.is_a?(Hash) ? value : { "_json" => value }
+          when FORM_TYPE
+            # Fallback flat (stdlib): il percorso reale con nesting passa dai params già parsati.
+            URI.decode_www_form(raw).to_h
+          end
+        rescue JSON::ParserError, ArgumentError
+          nil
+        end
+
+        def read_body(env)
+          input = env["rack.input"]
+          return nil if input.nil?
+
+          length = env["CONTENT_LENGTH"].to_i
+          return nil if length <= 0 || length > MAX_BODY_BYTES
+
+          input.rewind if input.respond_to?(:rewind)
+          raw = input.read(MAX_BODY_BYTES)
+          input.rewind if input.respond_to?(:rewind)
+          raw
+        end
+
+        def sanitize(value, depth)
+          return "[TRUNCATED]" if depth > MAX_DEPTH
+
+          case value
+          when Hash    then value.each_with_object({}) { |(key, val), acc| acc[key.to_s] = sanitize(val, depth + 1) }
+          when Array   then value.map { |item| sanitize(item, depth + 1) }
+          when String  then value.size > MAX_STRING ? "#{value[0, MAX_STRING]}…" : value
+          when Numeric, true, false, nil then value
+          else
+            if value.respond_to?(:original_filename)
+              "[FILE: #{value.original_filename}]"
+            else
+              "[OBJECT: #{value.class.name}]"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/request_context.rb

@@ -20,7 +20,11 @@ module CloseYourIt
         if enabled?
           # trace_id sempre (correlazione log↔errori), anche con capture_request OFF.
           CloseYourIt::Scope.current.trace_id = trace_id_for(env)
-          CloseYourIt::Scope.current.request = build_request(env) if CloseYourIt.configuration.capture_request
+          if CloseYourIt.configuration.capture_request
+            CloseYourIt::Scope.current.request = build_request(env)
+            # Riferimento all'env per l'estrazione LAZY del body (request.data) a evento costruito.
+            CloseYourIt::Scope.current.rack_env = env
+          end
         end
         @app.call(env)
       ensure

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):
@@ -34,7 +35,7 @@ module CloseYourIt
       end
     end
 
-    attr_accessor :request, :trace_id
+    attr_accessor :request, :trace_id, :rack_env
     attr_reader :user, :tags, :extra, :contexts, :breadcrumbs
 
     def initialize
@@ -65,14 +66,22 @@ 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        = {}
       @extra       = {}
       @contexts    = {}
       @request     = nil
+      @rack_env    = 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),
@@ -85,7 +94,7 @@ module CloseYourIt
         "tags"        => scrub(presence(@tags)),
         "extra"       => scrub(presence(@extra)),
         "contexts"    => scrub(presence(@contexts)),
-        "request"     => @request,
+        "request"     => request_payload,
         "breadcrumbs" => breadcrumbs_payload
       }.reject { |_key, value| value.nil? }
     end
@@ -101,6 +110,24 @@ module CloseYourIt
       Scrubber.new(CloseYourIt.configuration).filter_params(hash)
     end
 
+    # Request context + body params (`request.data`) estratti LAZY qui — cioè solo quando un
+    # evento viene davvero costruito, mai sul percorso felice della richiesta.
+    def request_payload
+      return nil if @request.nil?
+
+      data = request_body_data
+      data ? @request.merge("data" => data) : @request
+    end
+
+    def request_body_data
+      return nil unless CloseYourIt.configuration.capture_request_body
+      return nil if @rack_env.nil?
+
+      Rails::RequestBody.extract(@rack_env)
+    rescue StandardError
+      nil
+    end
+
     # `user.id` sempre; email/ip_address/username solo con `send_pii` (il backend li strippa
     # comunque — difesa in profondità).
     def serialize_user

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.4.0"
 end

data/lib/closeyourit-ruby.rb

@@ -16,15 +16,21 @@ 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/request_body"
 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.4.0
 platform: ruby
 authors:
 - Alessio Bussolari
@@ -43,23 +43,30 @@ 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/line_cache.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_body.rb
 - lib/closeyourit/rails/request_context.rb
 - lib/closeyourit/scope.rb
 - 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