closeyourit-ruby 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5753e09db20e85c04e6aae3b91549d07a07512a3f8af5646497be79a9295c9c7
-  data.tar.gz: 8718d9c9ddcde3b3829fb1d40489205e1beaec9ab0f8a9f96e4a1740455bfd1a
+  metadata.gz: 1482102089ba9e319a50f2d3822b63fc76ddc9a63c6c629f1d7cdc53022ca362
+  data.tar.gz: f312feb36b22702dca3109c62f623ba4484d25caf82dc9b25c807fe89f2ea2ba
 SHA512:
-  metadata.gz: 0b5b476a1825d5a06522e09d8b4835e07d903aa415f64768f45cd20e4ebd68e43cb41b492c99d9b520c60f187fdf452eea2ae06cc7c795d7223250f829c5c729
-  data.tar.gz: 7965dae2df4182cff157043c24e0bd6aee8bd126f3e50958514cb4cc78274a066b59adc7908318f1ee34e82baa265cbf8b45c5e6c8848a58e3cd1a9a8f1418ec
+  metadata.gz: 4f6a4d467f80966599d057452927a75c17126cb01def6de0d1e365cb0fa5dcbd458122e3b860b05906d35bb307b29eed0d8e9ee9b5afb1b4008170dd3462205d
+  data.tar.gz: 6f4a5ee0fb8dea5b160c1447624d1f409a1a36df63700c46dc66390c9d4fc2ab932e04a1c50c2dacec9c0202f73af7b697250786bfd52f8d6303fdaaebfdbff8

data/README.md

@@ -74,6 +74,7 @@ end
 | `async_threads` | `cpu/2` | Thread di invio; `0` = sincrono (test) |
 | `trap_signals` | `false` | Intercetta `SIGTERM` per garantire il flush di fine-vita (deploy/Kamal); opt-in perché sovrascrive un eventuale handler `TERM` dell'app ospite (vedi [Flush di fine-vita](#flush-di-fine-vita)) |
 | `slow_query_threshold_ms` | `100` | Soglia query lente |
+| `excluded_query_patterns` | `solid_queue_`, `solid_cache_`, `solid_cable_` | Query da NON misurare come rallentamento — **Regexp** (pattern) o **String** (testo letterale). Vale solo per la misura: breadcrumb e profiling N+1 vedono tutto |
 | `slow_method_threshold_ms` | `200` | Soglia metodi lenti |
 | `capture_request` | `true` | Cattura il contesto HTTP della richiesta (method/url/header allowlist) |
 | `request_header_allowlist` | `Accept`, `Content-Type`, `User-Agent`, `Referer` | Header inviati (mai Authorization/Cookie) |
@@ -92,6 +93,7 @@ end
 | `logs_flush_interval` | `5` | Secondi tra i flush periodici del buffer log |
 | `capture_rails_logs` | `false` | Inoltra anche `Rails.logger` allo stream — attenzione al volume (soglia `capture_rails_logs_min_level`) |
 | `capture_rails_logs_min_level` | `:warn` | Soglia **dedicata** del broadcast `Rails.logger` (distinta da `logs_min_level`): default conservativo per non inondare lo stream col rumore `info` del framework |
+| `excluded_log_patterns` | `[]` | Righe del broadcast `Rails.logger` da scartare per **testo** — **Regexp** (pattern) o **String** (testo letterale). Per il rumore che non è un'eccezione; le eccezioni le copre già `excluded_exceptions` |
 | `detect_performance_issues` | `false` | Master switch dei **verdetti** performance (N+1, query count, request/HTTP esterne lente). Opt-in: profila ogni query → overhead (vedi [Performance issues](#performance-issues-opt-in)) |
 | `n_plus_one_threshold` | `10` | Ripetizioni dello stesso `[fingerprint, call-site]` in una richiesta oltre cui = `n_plus_one` |
 | `query_count_threshold` | `100` | Query totali in una richiesta oltre cui = `high_query_count` |
@@ -99,6 +101,29 @@ end
 | `slow_request_threshold_ms` | `1000` | Durata totale della richiesta (ms) oltre cui = `slow_request` |
 | `slow_external_threshold_ms` | `1000` | Durata di una singola HTTP esterna (ms) oltre cui = `slow_external_http` |
 | `capture_external_http` | `true` | Strumenta `Net::HTTP` per rilevare le HTTP esterne (effettivo solo con `detect_performance_issues`) |
+| `monitor_jobs` | `true` | Misura durata e attesa in coda dei background job (ActiveJob + Sidekiq) → metriche `slow_job`/`job_queue_latency` (vedi [Metriche dei background job](#metriche-dei-background-job)) |
+| `slow_job_threshold_ms` | `5000` | Durata del job (ms) oltre cui = `slow_job` |
+| `job_queue_latency_threshold_ms` | `60000` | Attesa in coda (enqueue→esecuzione, ms) oltre cui = `job_queue_latency` |
+| `jobs_sample_rate` | `1.0` | Frazione dei job oltre soglia effettivamente inviata (`1.0` tutti, `0.0` niente) |
+| `propagate_trace_context` | `false` | Propaga il **trace context W3C** (`traceparent`/`tracestate`) alle chiamate `Net::HTTP` e mappa il `trace_id` degli eventi sul trace-id W3C entrante (vedi [Propagazione W3C](#propagazione-w3c-opt-in)) |
+| `trace_propagation_allowlist` | `[]` | Host autorizzati a ricevere gli header W3C — **String** (host esatto, case-insensitive) o **Regexp** (sottodomini). Vuoto = nessuna destinazione |
+
+## Propagazione W3C (opt-in)
+
+Correla le richieste Ruby e le chiamate in uscita con lo standard **[W3C Trace Context](https://www.w3.org/TR/trace-context/)**
+(`traceparent`/`tracestate`) — nessun formato proprietario. È un *propagation bridge*, non un tracer
+completo: adotta il contesto entrante o ne genera uno root, e lo inoltra alle chiamate `Net::HTTP`.
+
+```ruby
+CloseYourIt.init do |c|
+  c.propagate_trace_context     = true
+  c.trace_propagation_allowlist = [ "api.interno.example", /\.svc\.internal\z/ ]
+end
+```
+
+- **Ingresso**: un `traceparent` entrante valido diventa il `trace_id` degli eventi CloseYourIt → l'errore/metrica della richiesta si allinea alla traccia distribuita. Un header malformato viene ignorato (si genera un root); un servizio d'origine (senza header) parte comunque con un contesto W3C.
+- **Uscita**: gli header vengono iniettati **solo** verso gli host della `trace_propagation_allowlist` (limitata per destinazione) e mai verso l'endpoint CloseYourIt stesso. Un redirect verso un host non elencato non riceve nulla.
+- **Privacy**: verso host non autorizzati non parte alcun header; l'header `baggage` (che può portare contesto interno/PII) **non viene mai** emesso.
 
 ## Cosa cattura
 
@@ -172,6 +197,21 @@ Abbassala esplicitamente (es. `config.capture_rails_logs_min_level = :info`) sol
 `info` del framework. I log dei background job ereditano il `trace_id = job_id`, così log ed errore
 dello stesso job si correlano.
 
+Il broadcast rispetta anche **`excluded_exceptions`**: se la riga nomina una classe esclusa non viene
+inoltrata. Serve perché un'eccezione tolta dal canale errori rientrava da quello dei log — Rails la
+registra comunque con `logger.error`. Con le esclusioni di default questo copre già
+`ActionController::RoutingError`, cioè le favicon mancanti e le scansioni dei bot, che in produzione
+sono la voce di gran lunga più numerosa dello stream. Per il rumore ripetuto che **non** è
+un'eccezione c'è `excluded_log_patterns`:
+
+```ruby
+config.excluded_log_patterns = [ /SolidQueue-[\d.]+ Error in thread/, "Rendered layout" ]
+```
+
+Le stringhe valgono come testo letterale (vengono escapate), i `Regexp` come pattern. Entrambe le
+liste gatano **solo** il mirror di `Rails.logger`: un `CloseYourIt.log` scritto di proposito non viene
+mai silenziato.
+
 #### Flush di fine-vita
 
 Il buffer log viene svuotato automaticamente allo **shutdown del processo**: `CloseYourIt.init` registra
@@ -180,6 +220,31 @@ buffer), così i log sotto-batch di rake/CLI non vanno persi all'uscita. `SIGTER
 termina il processo **senza** eseguire gli `at_exit`: imposta `trap_signals = true` per intercettarlo e
 convertirlo in un exit pulito, oppure chiama `CloseYourIt.shutdown` esplicitamente prima di terminare.
 
+#### Server che forkano (Puma cluster, Sidekiq, Unicorn)
+
+I server che precaricano l'app (`preload_app!`) inizializzano la gemma nel processo **master**, poi
+forkano i worker. Il worker pool asincrono e il timer del buffer log sono **thread**, e i thread non
+sopravvivono a un `fork`: nel figlio quelle risorse sarebbero ereditate ma inerti e gli eventi non
+partirebbero mai. La gemma **rileva il cambio di PID da sé** (lazy, al primo evento del figlio) e ricrea
+worker e buffer nel processo corrente — nella maggior parte dei casi non devi fare nulla.
+
+Per ricrearle **subito** dopo il fork (invece di attendere il primo evento) chiama
+`CloseYourIt.after_fork` nel worker hook del tuo server:
+
+```ruby
+# Puma (config/puma.rb)
+on_worker_boot { CloseYourIt.after_fork }
+
+# Sidekiq (config/initializers/sidekiq.rb)
+Sidekiq.configure_server { |config| config.on(:startup) { CloseYourIt.after_fork } }
+
+# Unicorn (config/unicorn.rb)
+after_fork { |server, worker| CloseYourIt.after_fork }
+```
+
+`CloseYourIt.after_fork` abbandona le risorse ereditate **senza drenarle** (non tenta un join sui thread
+del padre e non riflusha il buffer, che rispedirebbe eventi del padre) ed è sicuro da chiamare più volte.
+
 ### Contesto, breadcrumbs e messaggi (manuale)
 
 ```ruby
@@ -201,6 +266,21 @@ all'evento d'errore catturato nello stesso contesto di esecuzione.
 Il Railtie si iscrive a `sql.active_record`: ogni query oltre `slow_query_threshold_ms` (esclusi
 `SCHEMA`/`CACHE`) viene inviata come `slow_query` alla pipeline metriche. Lo SQL è **offuscato** (bind esclusi).
 
+Sono escluse anche le query che combaciano con `excluded_query_patterns` — di default le tabelle di
+servizio del Solid stack (`solid_queue_`, `solid_cache_`, `solid_cable_`). Sono infrastruttura del
+framework: una loro query lenta non si corregge leggendo il proprio repo, dice solo che il database è
+in contesa, e in compenso sommerge le query dell'applicazione (su un backend reale erano il **62%**
+dei campioni). Per misurarle davvero azzera la lista:
+
+```ruby
+config.excluded_query_patterns = []                      # misura tutto
+config.excluded_query_patterns += [ "pg_stat_activity" ]  # o aggiungi le tue
+```
+
+Il filtro vale solo per la **misura**: le breadcrumb «quali query prima del crash» e il profiling N+1
+continuano a vedere tutte le query, perché lì una tabella di servizio letta molte volte è essa stessa
+un sintomo.
+
 ### Metodi lenti → metriche
 
 ```ruby
@@ -257,6 +337,36 @@ tutte ritoccabili.
 > switch. (Pendant server-side dei verdetti `performance_issue` di closeyourit-js: qui i `subtype`
 > sono quelli del backend Rails — N+1, query count, request/HTTP esterne lente.)
 
+## Metriche dei background job
+
+Oltre agli **errori** dei job (sezione precedente), la gemma misura **automaticamente** durata di
+esecuzione e attesa in coda dei background job e, oltre le soglie, invia metriche `performance_issue`
+sulla pipeline metriche (`/api/v1/projects/:id/metrics`). Funziona con **ActiveJob** (via notifiche
+`ActiveSupport::Notifications`) e con **Sidekiq** (server middleware), senza strumentazione manuale.
+Due `subtype`:
+
+- **`slow_job`** — la durata del `perform` supera `slow_job_threshold_ms` (default 5000 ms).
+- **`job_queue_latency`** — l'attesa in coda (dall'enqueue all'inizio dell'esecuzione) supera
+  `job_queue_latency_threshold_ms` (default 60000 ms): coda intasata o worker insufficienti.
+
+Ogni metrica porta la **label** (nome della classe del job), la **queue**, l'**adapter**
+(`active_job`/`sidekiq`), l'**attempt** (numero di esecuzione: rende visibili i **retry**), la
+**release** e il **trace_id** (= `job_id` / `jid`, che correla la metrica a log ed errori dello stesso
+job). **Gli argomenti del job non vengono mai inviati** (solo la label).
+
+È **ON di default** (a differenza dei verdetti performance opt-in): la visibilità dei job lenti, in
+ritardo o ripetutamente ritentati non deve richiedere configurazione in ogni app, e l'overhead è basso
+(una notifica per job, non il profiling di ogni query). Il rumore è tenuto a bada dalle **soglie** (i
+job normali restano sotto soglia → nessuna metrica) e dal **sampling** (`jobs_sample_rate`, applicato
+solo ai job già oltre soglia). Per spegnerlo del tutto:
+
+```ruby
+CloseYourIt.init do |c|
+  # …endpoint_url / token / project_id…
+  c.monitor_jobs = false
+end
+```
+
 ## Privacy & PII
 
 Privacy-by-default (`send_pii = false`). In sintesi:
@@ -277,17 +387,45 @@ Privacy-by-default (`send_pii = false`). In sintesi:
 Il trasporto è fire-and-forget: non solleva mai e non blocca la request. Per non lasciare
 fallimenti silenziosi, ogni risposta HTTP non-2xx (es. `401` token errato, `404` progetto
 inesistente) viene loggata a `warn`, così come gli eventi scartati a coda piena. I contatori
-sono ispezionabili a runtime:
+sono ispezionabili a runtime (`snapshot` è un alias di `to_h`):
 
 ```ruby
 CloseYourIt.stats.to_h
-# => { enqueued: 128, dropped: 0, sent: 126, failed: 2 }
+# => { enqueued: 128, dropped: 1, sent: 125, failed: 2, timeout: 1 }
 ```
 
 - `enqueued` — eventi accettati per l'invio
-- `dropped` — scartati perché la coda async era piena (mai backpressure)
+- `dropped` — scartati prima dell'invio: coda async piena, `before_send` → `nil`/eccezione, sampling
 - `sent` — risposta HTTP 2xx
 - `failed` — errore di rete o status non-2xx (vedi i log a `warn`)
+- `timeout` — sotto-conteggio di `failed`: fallimenti per timeout di rete (connettività)
+
+### Hook `on_diagnostic` (opt-in)
+
+Per osservare il ciclo di vita di ogni evento senza abilitare log rumorosi, registra un hook. È
+invocato a ogni tappa — `:enqueue`, `:send`, `:drop`, `:timeout`, `:shutdown` — con dettagli privi
+di dati sensibili:
+
+```ruby
+CloseYourIt.init do |c|
+  # ...
+  c.on_diagnostic = ->(event, details) do
+    StatsD.increment("closeyourit.#{event}", tags: details) # es. inoltra a metriche interne
+  end
+end
+```
+
+- `:enqueue` — `{ path: … }` accodato per l'invio
+- `:send` — `{ status: 202 }` consegnato (2xx)
+- `:drop` — scartato: `{ reason: :queue_full | :before_send | :sampled | :error | :response | :network, … }`
+- `:timeout` — `{ error: "Net::OpenTimeout" }` timeout di rete
+- `:shutdown` — `{ stats: {…} }` snapshot alla terminazione del processo, emesso una sola volta per
+  sessione (best-effort: invii ancora in volo oltre il breve timeout di drain possono non esservi
+  riflessi — il drain non blocca l'uscita)
+
+L'hook è **locale e non ricorsivo**: non invia mai telemetria, e una notifica emessa dal suo interno
+è soppressa — non può innescare loop di auto-monitoraggio. Un hook che solleva è isolato (loggato,
+mai propagato nell'app). Tienilo veloce: gira sincrono nel thread chiamante, come `before_send`.
 
 ## Sviluppo
 

data/lib/closeyourit/background_worker.rb

@@ -26,6 +26,7 @@ module CloseYourIt
       unless accepted
         CloseYourIt.stats.increment(:dropped)
         CloseYourIt.internal_logger.warn("CloseYourIt background worker: coda piena, evento scartato")
+        CloseYourIt.notify_diagnostic(:drop, reason: :queue_full)
       end
 
       accepted

data/lib/closeyourit/client.rb

@@ -21,11 +21,19 @@ module CloseYourIt
     def capture_event(event)
       payload = event.to_h
       payload = @configuration.before_send.call(payload) if @configuration.before_send
-      return nil if payload.nil?
+      if payload.nil?
+        # before_send ha scartato l'evento (ritorna nil): scarto voluto, reso visibile (CYRB-12).
+        CloseYourIt.stats.increment(:dropped)
+        CloseYourIt.notify_diagnostic(:drop, reason: :before_send)
+        return nil
+      end
 
       path = event.ingest_path(@configuration.project_id)
       accepted = @worker.perform { @transport.send_event(payload, path: path) }
-      CloseYourIt.stats.increment(:enqueued) if accepted
+      if accepted
+        CloseYourIt.stats.increment(:enqueued)
+        CloseYourIt.notify_diagnostic(:enqueue, path: path)
+      end
       payload
     rescue StandardError => e
       # La telemetria non deve MAI propagare nel path dell'app ospite: capture_event è invocato dal
@@ -33,6 +41,8 @@ module CloseYourIt
       # malformato) e before_send sono valutati qui in modo sincrono → se sollevano, assorbiamo,
       # logghiamo e scartiamo l'evento invece di disturbare la query ospite. Vedi CYRB-2.
       CloseYourIt.internal_logger.error("CloseYourIt client: #{e.class}: #{e.message}")
+      CloseYourIt.stats.increment(:dropped)
+      CloseYourIt.notify_diagnostic(:drop, reason: :error, error: e.class.name)
       nil
     end
 
@@ -45,13 +55,25 @@ module CloseYourIt
       return nil if events.nil? || events.empty?
 
       payloads = events.map(&:to_h)
-      payloads = payloads.filter_map { |payload| @configuration.before_send.call(payload) } if @configuration.before_send
+      if @configuration.before_send
+        kept = payloads.filter_map { |payload| @configuration.before_send.call(payload) }
+        # I log che before_send porta a nil sono scarti voluti: contabilizzali come gli errori/metriche
+        # (parità con #capture_event), altrimenti sparirebbero silenziosamente dai contatori (CYRB-12).
+        (payloads.size - kept.size).times do
+          CloseYourIt.stats.increment(:dropped)
+          CloseYourIt.notify_diagnostic(:drop, reason: :before_send)
+        end
+        payloads = kept
+      end
       return nil if payloads.empty?
 
       path = events.first.ingest_path(@configuration.project_id)
       payloads.each_slice(LOGS_MAX_BATCH) do |chunk|
         accepted = @worker.perform { @transport.send_event(chunk, path: path) }
-        CloseYourIt.stats.increment(:enqueued) if accepted
+        next unless accepted
+
+        CloseYourIt.stats.increment(:enqueued)
+        CloseYourIt.notify_diagnostic(:enqueue, path: path, batch: chunk.size)
       end
       payloads
     end

data/lib/closeyourit/configuration.rb

@@ -15,7 +15,18 @@ module CloseYourIt
     # Header HTTP catturati nel contesto request (mai Authorization/Cookie → niente PII/segreti).
     DEFAULT_REQUEST_HEADER_ALLOWLIST = %w[Accept Content-Type User-Agent Referer].freeze
 
-    attr_accessor :endpoint_url, :token, :project_id, :environment, :before_send,
+    # Tabelle di servizio del Solid stack: sono infrastruttura del framework, non codice
+    # dell'applicazione. Una loro query lenta non si può correggere leggendo il proprio repo — dice
+    # solo che il database è in contesa, cosa che le query dell'app raccontano già. Escluse per
+    # DEFAULT dalla misura dei rallentamenti perché altrimenti la sommergono: su closeyourit-rails il
+    # 2026-07-30 erano circa 2.740 campioni su 4.400 (62%), tutti fra i 250 e i 655 ms (CYRB-18).
+    DEFAULT_EXCLUDED_QUERY_PATTERNS = [
+      /\bsolid_queue_/,
+      /\bsolid_cache_/,
+      /\bsolid_cable_/
+    ].freeze
+
+    attr_accessor :endpoint_url, :token, :project_id, :environment, :before_send, :on_diagnostic,
                   :async_threads, :background_worker_max_queue,
                   :slow_query_threshold_ms, :slow_method_threshold_ms,
                   :send_pii, :obfuscate_sql, :send_server_name,
@@ -28,9 +39,12 @@ module CloseYourIt
                   :capture_rails_logs, :logs_min_level, :capture_rails_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, :trap_signals
+                  :capture_external_http, :trap_signals,
+                  :monitor_jobs, :slow_job_threshold_ms, :job_queue_latency_threshold_ms,
+                  :jobs_sample_rate, :propagate_trace_context
     attr_writer :release, :project_root
-    attr_reader :excluded_exceptions, :filter_parameters, :scrub_message_patterns
+    attr_reader :excluded_exceptions, :excluded_log_patterns, :excluded_query_patterns,
+                :filter_parameters, :scrub_message_patterns, :trace_propagation_allowlist
 
     def initialize
       @endpoint_url = ENV.fetch("CLOSEYOURIT_ENDPOINT_URL", nil)
@@ -42,6 +56,12 @@ module CloseYourIt
       @excluded_exceptions = DEFAULT_EXCLUDED_EXCEPTIONS.dup
       @before_send         = nil
 
+      # Hook diagnostico opt-in: `->(event, details) { ... }` invocato a ogni tappa del ciclo di vita
+      # di un evento (:enqueue, :send, :drop, :timeout, :shutdown) con dettagli privi di dati sensibili
+      # (es. `{ reason: :queue_full }`, `{ status: 429 }`). Locale e non ricorsivo: non invia telemetria
+      # e non può innescare loop di auto-monitoraggio (vedi CloseYourIt.notify_diagnostic, CYRB-12).
+      @on_diagnostic = nil
+
       @async_threads               = default_threads
       @background_worker_max_queue  = 30
 
@@ -52,6 +72,9 @@ module CloseYourIt
 
       @slow_query_threshold_ms  = 100
       @slow_method_threshold_ms = 200
+      # Query da NON misurare come rallentamento (match sul testo SQL). Default: le tabelle di servizio
+      # del Solid stack. Chi vuole misurarle davvero azzera la lista.
+      @excluded_query_patterns = DEFAULT_EXCLUDED_QUERY_PATTERNS.dup
 
       @send_pii         = false
       @obfuscate_sql    = true
@@ -98,6 +121,10 @@ module CloseYourIt
       # inonderebbe lo stream con decine di migliaia di log-entry/min (CYRB-7). Chi vuole anche gli info
       # del framework la abbassa esplicitamente (es. :info).
       @capture_rails_logs_min_level = :warn
+      # Rumore del broadcast Rails.logger che NON è un'eccezione, e quindi excluded_exceptions non può
+      # coprire: righe ripetute del framework o di una gemma. Regexp sul testo del messaggio, default
+      # vuoto. Vale SOLO per il broadcast automatico, mai per CloseYourIt.log esplicito.
+      @excluded_log_patterns = []
 
       # 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
@@ -110,6 +137,26 @@ module CloseYourIt
       @slow_external_threshold_ms = 1000     # singola chiamata HTTP esterna
       @capture_external_http     = true      # strumenta Net::HTTP (solo se detect_performance_issues)
 
+      # Metriche dei background job: durata di esecuzione e attesa in coda (queue latency) per ActiveJob
+      # e Sidekiq. ON di default (a differenza di detect_performance_issues): la visibilità dei job
+      # lenti/in ritardo/ritentati non deve richiedere strumentazione manuale in ogni app (CYRB-14), e
+      # l'overhead è basso — una notifica per job, non il profiling di ogni query. Il rumore è tenuto a
+      # bada dalle soglie (job normali sotto soglia = niente metrica) e dal sampling. La label è il nome
+      # della classe del job; gli argomenti non vengono MAI inviati.
+      @monitor_jobs                   = true
+      @slow_job_threshold_ms          = 5000     # durata del perform oltre cui = slow_job
+      @job_queue_latency_threshold_ms = 60_000   # attesa enqueue→esecuzione oltre cui = job_queue_latency
+      @jobs_sample_rate               = 1.0      # frazione dei candidati oltre soglia effettivamente inviata
+
+      # Propagazione W3C trace context (traceparent/tracestate) verso i servizi esterni chiamati via
+      # Net::HTTP. OPT-IN, default OFF: iniettare header d'uscita attraversa un trust boundary e va deciso
+      # per-app. È limitata PER DESTINAZIONE dalla allowlist (host esatti, case-insensitive, o Regexp per i
+      # sottodomini); lista vuota = nessuna destinazione. Mai verso host non elencati, mai come `baggage`
+      # (che può portare PII). In ingresso un traceparent valido diventa il trace_id degli eventi
+      # CloseYourIt → gli errori/metriche della richiesta si correlano alla traccia distribuita (CYRB-15).
+      @propagate_trace_context     = false
+      @trace_propagation_allowlist = []
+
       # Radice del progetto: base per il filename relativo dei frame (culprit cross-SDK). Lazy:
       # auto-rilevata da Rails.root o Dir.pwd al primo accesso se non impostata esplicitamente.
       @project_root = nil
@@ -123,10 +170,28 @@ module CloseYourIt
       @excluded_exceptions = Array(list).map { |item| item.is_a?(Regexp) ? item : item.to_s }
     end
 
+    # Pattern del broadcast Rails.logger da scartare. Le stringhe diventano Regexp (match letterale
+    # sul testo): chi scrive `config.excluded_log_patterns = ["Rendered layout"]` intende quello.
+    def excluded_log_patterns=(list)
+      @excluded_log_patterns = Array(list).map { |item| item.is_a?(Regexp) ? item : Regexp.new(Regexp.escape(item.to_s)) }
+    end
+
+    # Query da non misurare. Stessa normalizzazione di excluded_log_patterns: String = testo letterale
+    # (un nome di tabella si scrive così, non come pattern), Regexp = pattern.
+    def excluded_query_patterns=(list)
+      @excluded_query_patterns = Array(list).map { |item| item.is_a?(Regexp) ? item : Regexp.new(Regexp.escape(item.to_s)) }
+    end
+
     def filter_parameters=(list)
       @filter_parameters = Array(list)
     end
 
+    # Destinazioni autorizzate a ricevere gli header di trace W3C. String = host esatto (match
+    # case-insensitive), Regexp = pattern (per sottodomini/famiglie di host). Lista vuota = nessuno.
+    def trace_propagation_allowlist=(list)
+      @trace_propagation_allowlist = Array(list)
+    end
+
     def scrub_message_patterns=(list)
       @scrub_message_patterns = Array(list)
     end

data/lib/closeyourit/events/job_metric_event.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../event"
+
+module CloseYourIt
+  # Metrica `kind=performance_issue` per un background job che ha superato una soglia di DURATA
+  # (`subtype=slow_job`) o di ATTESA in coda (`subtype=job_queue_latency`). Spedita sulla pipeline
+  # metriche (`/api/v1/projects/:id/metrics`), come slow_query/slow_method e i verdetti performance.
+  #
+  # `label` è il nome della CLASSE del job — mai gli argomenti (privacy: come slow_method invia solo
+  # label/durata). `attempt` rende visibili i retry; `trace_id` (= job_id ActiveJob / jid Sidekiq)
+  # correla la metrica a log ed errori dello stesso job. `duration_ms` è il valore misurato del subtype
+  # (durata del perform per slow_job, attesa in coda per job_queue_latency) — stessa convenzione del
+  # Rollup. I campi nil vengono omessi.
+  class JobMetricEvent < 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,
+        "release" => @configuration.release,
+        "trace_id" => @attrs[:trace_id],
+        "label" => @attrs[:job_class],
+        "queue" => @attrs[:queue],
+        "adapter" => @attrs[:adapter],
+        "attempt" => @attrs[:attempt],
+        "sdk" => sdk
+      )
+    end
+
+    def ingest_path(project_id)
+      "/api/v1/projects/#{project_id}/metrics"
+    end
+  end
+end

data/lib/closeyourit/log_buffer.rb

@@ -37,6 +37,12 @@ module CloseYourIt
       # before_send che solleva su UN evento non deve propagare nell'app né uccidere il TimerTask
       # (che altrimenti smette di flushare → log accumulati e persi). Ingoiato e loggato.
       CloseYourIt.internal_logger.error("CloseYourIt log buffer: #{e.class}: #{e.message}")
+      # Il batch è già stato drenato: se flush_logs solleva, quei log sono persi. Contabilizzali come
+      # scarti per non lasciare un fallimento silenzioso (CYRB-12). `batch.to_a` è nil-safe.
+      batch.to_a.size.times do
+        CloseYourIt.stats.increment(:dropped)
+        CloseYourIt.notify_diagnostic(:drop, reason: :error)
+      end
     end
 
     def shutdown

data/lib/closeyourit/rails/active_job_extension.rb

@@ -3,17 +3,45 @@
 module CloseYourIt
   module Rails
     # Incluso in ActiveJob::Base (via railtie `on_load(:active_job)`): cattura gli errori dei job
-    # (oggi persi) con il contesto del job, poi ri-solleva. La logica vive in `.monitor` per essere
+    # (oggi persi) con il contesto del job. La logica vive in `.monitor`/`.report_discarded` per essere
     # testabile senza ActiveSupport/ActiveJob.
+    #
+    # CYRB-19: `around_perform` gira DENTRO `perform_now`, mentre `retry_on`/`discard_on` (rescue_from)
+    # sono valutati FUORI, dopo i callback. Catturare nell'around_perform significa quindi segnalare
+    # OGNI tentativo — anche quelli che verranno ritentati con successo — perché il reporter vede
+    # l'errore prima che il retry possa zittirlo, e ogni tentativo solleva una nuova istanza (la
+    # deduplica interna, per-istanza, non interviene). Su ActiveJob 7.1+ deleghiamo la segnalazione ad
+    # `after_discard`, che Rails invoca al fallimento definitivo (retry_on esauriti o eccezione non
+    # gestita), mai sui tentativi che `retry_on` ritenta → una sola occorrenza per job.
+    #
+    # Limiti noti (per costruzione di ActiveJob, non del client):
+    # - `after_discard` NON scatta per gli errori intercettati da un `rescue_from` custom: sono gestiti
+    #   dall'app, quindi non li segnaliamo più come "non gestiti" (prima lo facevamo, impropriamente).
+    # - I retry a livello di ADAPTER (es. Sidekiq) SENZA `retry_on` risollevano l'errore non gestito:
+    #   `after_discard` scatta a ogni esecuzione, quindi lì la de-duplicazione per tentativo non si
+    #   applica (comportamento invariato rispetto a prima).
+    # Sulle versioni prive di `after_discard` restiamo al fallback legacy (cattura nell'around_perform).
     module ActiveJobExtension
+      # Scope arricchito durante il `perform` tramandato ad `after_discard`. Legato all'ISTANZA del job
+      # (ogni retry ne crea una nuova, deserializzata) → vive esattamente quanto serve, niente bleed tra
+      # job o thread; il reset di fine `perform` lo sgancia solo dallo storage, non muta l'oggetto.
+      STASHED_SCOPE_IVAR = :@__closeyourit_stashed_scope
+
       def self.included(base)
         base.around_perform do |job, block|
           CloseYourIt::Rails::ActiveJobExtension.monitor(job) { block.call }
         end
+
+        return unless base.respond_to?(:after_discard)
+
+        base.after_discard do |job, exception|
+          CloseYourIt::Rails::ActiveJobExtension.report_discarded(job, exception)
+        end
       end
 
-      # Esegue il job arricchendo lo scope con tag/context; cattura l'errore (handled:false) e
-      # ri-solleva; resetta lo scope a fine job (no bleed tra job sullo stesso thread).
+      # Esegue il job arricchendo lo scope con tag/context; resetta lo scope a fine job (no bleed tra
+      # job sullo stesso thread). Su ActiveJob 7.1+ NON cattura l'errore (lo fa `after_discard` solo al
+      # fallimento definitivo): qui tramanda lo scope al job e ri-solleva. Sul fallback legacy cattura.
       def self.monitor(job)
         return yield unless CloseYourIt.configuration.report_active_job_errors
 
@@ -21,13 +49,41 @@ module CloseYourIt
           apply_job_scope(job)
           yield
         rescue Exception => e # rubocop:disable Lint/RescueException
-          CloseYourIt.capture_exception(e, handled: false)
+          if report_on_discard?(job)
+            job.instance_variable_set(STASHED_SCOPE_IVAR, CloseYourIt::Scope.current)
+          else
+            CloseYourIt.capture_exception(e, handled: false)
+          end
           raise
         ensure
           CloseYourIt::Scope.reset!
         end
       end
 
+      # Aggancio `after_discard` (ActiveJob 7.1+): il job è definitivamente fallito, quindi segnaliamo
+      # l'errore UNA sola volta (handled:false). Riprendiamo lo scope arricchito durante il `perform`
+      # (tramandato da `monitor`) così il report conserva breadcrumb/tag/contesti raccolti nel job;
+      # `apply_job_scope` rinfresca i campi standard con `executions` finale senza perdere i custom.
+      def self.report_discarded(job, exception)
+        return unless CloseYourIt.configuration.report_active_job_errors
+
+        begin
+          stashed = job.instance_variable_get(STASHED_SCOPE_IVAR)
+          CloseYourIt::Scope.current = stashed if stashed
+          apply_job_scope(job)
+          CloseYourIt.capture_exception(exception, handled: false)
+        ensure
+          job.remove_instance_variable(STASHED_SCOPE_IVAR) if job.instance_variable_defined?(STASHED_SCOPE_IVAR)
+          CloseYourIt::Scope.reset!
+        end
+      end
+
+      # true quando ActiveJob espone `after_discard` (7.1+): la segnalazione è delegata lì, così
+      # `monitor` non cattura i tentativi intermedi. false → fallback legacy (cattura nell'around_perform).
+      def self.report_on_discard?(job)
+        job.class.respond_to?(:after_discard)
+      end
+
       def self.apply_job_scope(job)
         CloseYourIt.set_tag("job.class", job.class.name)
         CloseYourIt.set_tag("job.queue", job.queue_name) if job.respond_to?(:queue_name)

data/lib/closeyourit/rails/log_broadcast.rb

@@ -18,13 +18,20 @@ module CloseYourIt
         self.level = LEVEL_BY_SYMBOL.fetch(min_level.to_sym, 2)
       end
 
-      # Sovrascrive il punto unico di ::Logger: filtra per soglia e re-inoltra a CloseYourIt.log.
+      # Sovrascrive il punto unico di ::Logger: filtra per soglia e per esclusioni, poi re-inoltra a
+      # CloseYourIt.log. Il secondo filtro esiste perché la soglia da sola non distingue il rumore: una
+      # `ActionController::RoutingError` da favicon mancante è un `logger.error` come un altro, e senza
+      # controllare il TESTO rientrava dal canale log dopo essere stata esclusa da quello degli errori
+      # (CYRB-17). Il gating vive qui e non in `CloseYourIt.log`: quel metodo serve anche il dev che
+      # scrive un log di proposito, e le sue righe non si silenziano.
       def add(severity, message = nil, progname = nil)
         severity ||= ::Logger::UNKNOWN
         return true if severity < level
 
         text = message || (block_given? ? yield : nil) || progname
-        CloseYourIt.log(SEVERITY_LEVELS.fetch(severity, "info"), text) unless text.nil?
+        return true if text.nil? || CloseYourIt.ignored_log_message?(text)
+
+        CloseYourIt.log(SEVERITY_LEVELS.fetch(severity, "info"), text)
         true
       end
     end

data/lib/closeyourit/rails/net_http_patch.rb

@@ -12,6 +12,9 @@ module CloseYourIt
     module NetHTTPPatch
       def request(req, body = nil, &block)
         config = CloseYourIt.configuration
+        # Propagazione W3C: indipendente dal profiling (ha il suo opt-in), va fatta PRIMA del round-trip
+        # perché aggiunge header alla richiesta in uscita.
+        inject_trace_context(config, req)
         return super unless config.detect_performance_issues && config.capture_external_http
 
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -25,6 +28,53 @@ module CloseYourIt
 
       private
 
+      # Gestisce gli header di trace W3C sulla richiesta in uscita (solo con la propagazione opt-in ON).
+      # Verso una destinazione autorizzata inietta traceparent/tracestate; verso qualsiasi altra li
+      # RIMUOVE. La rimozione è la difesa contro il leak su redirect cross-host: se lo stesso oggetto
+      # request viene riusato per seguire un redirect verso un host non in allowlist, gli header della
+      # chiamata precedente non devono sopravvivere ("host esterni non ricevono header interni" — CYRB-15).
+      # baggage non viene mai né letto né emesso. Difensivo: mai solleva per colpa della propagazione.
+      def inject_trace_context(config, req)
+        return unless config.propagate_trace_context
+
+        context = deliverable_context(config)
+        if context.nil?
+          strip_trace_headers(req)
+        else
+          context.headers.each { |name, value| req[name] = value }
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Il trace context da consegnare a QUESTA destinazione, o nil se non va propagato nulla: host
+      # assente, endpoint CloseYourIt stesso (niente auto-propagazione), destinazione fuori allowlist,
+      # o scope privo di contesto.
+      def deliverable_context(config)
+        host = address
+        return nil if host.nil? || own_endpoint?(config, host)
+        return nil unless destination_allowed?(config, host)
+
+        CloseYourIt::Scope.current.trace_context
+      end
+
+      # La destinazione è autorizzata a ricevere il trace context? String = host esatto (case-insensitive),
+      # Regexp = pattern (sottodomini/famiglie). Lista vuota → sempre false (nessuna destinazione).
+      def destination_allowed?(config, host)
+        config.trace_propagation_allowlist.any? do |pattern|
+          pattern.is_a?(Regexp) ? pattern.match?(host) : pattern.to_s.casecmp?(host)
+        end
+      end
+
+      # Rimuove gli header di trace W3C che una chiamata precedente sullo stesso oggetto request possa
+      # aver lasciato. Solo i nostri header, mai altro; no-op se il request non li supporta.
+      def strip_trace_headers(req)
+        return unless req.respond_to?(:delete)
+
+        req.delete("traceparent")
+        req.delete("tracestate")
+      end
+
       def record_external(config, req, duration_ms)
         host = address
         return if host.nil? || own_endpoint?(config, host)