closeyourit-ruby 0.6.1 → 0.8.0

data/lib/closeyourit/rails/railtie.rb

@@ -10,6 +10,8 @@ require_relative "log_broadcast"
 require_relative "net_http_patch"
 require_relative "../subscribers/slow_query"
 require_relative "../subscribers/request_performance"
+require_relative "../subscribers/job_performance"
+require_relative "../sidekiq/job_metrics_middleware"
 
 module CloseYourIt
   module Rails
@@ -73,8 +75,9 @@ module CloseYourIt
         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.
+      # Strumenta Net::HTTP: rileva le chiamate esterne lente (solo con detect_performance_issues) e
+      # propaga il trace context W3C (solo con propagate_trace_context). Prepend incondizionato — i due
+      # opt-in sono valutati per-chiamata nel patch; con entrambi OFF è di fatto no-op (chiama super).
       initializer "closeyourit.instrument_net_http" do
         require "net/http"
         ::Net::HTTP.prepend(CloseYourIt::Rails::NetHTTPPatch) unless ::Net::HTTP.ancestors.include?(CloseYourIt::Rails::NetHTTPPatch)
@@ -87,6 +90,24 @@ module CloseYourIt
         end
       end
 
+      # Misura durata e attesa in coda dei job ActiveJob via notifiche ActiveSupport: `perform_start`
+      # dà l'attesa (now - enqueued_at) appena il job parte, `perform` dà la durata dell'esecuzione a
+      # fine job. Oltre soglia → metriche slow_job / job_queue_latency. No-op se monitor_jobs è OFF.
+      initializer "closeyourit.subscribe_active_job_performance" do
+        jobs = CloseYourIt::Subscribers::JobPerformance.new
+
+        ActiveSupport::Notifications.subscribe("perform_start.active_job") do |*args|
+          job = ActiveSupport::Notifications::Event.new(*args).payload[:job]
+          jobs.active_job_started(job) if job
+        end
+
+        ActiveSupport::Notifications.subscribe("perform.active_job") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          job = event.payload[:job]
+          jobs.active_job_performed(job, event.duration) if job
+        end
+      end
+
       # Cattura gli errori HANDLED riportati via Rails.error.report (Rails 7+).
       initializer "closeyourit.error_reporter" do
         if ::Rails.respond_to?(:error) && ::Rails.error.respond_to?(:subscribe)
@@ -110,11 +131,16 @@ module CloseYourIt
         end
       end
 
-      # Cattura gli errori dei job Sidekiq (solo se Sidekiq è presente).
+      # Cattura gli errori dei job Sidekiq + misura durata/attesa via server middleware (solo se
+      # Sidekiq è presente). Il middleware è no-op effettivo se monitor_jobs è OFF (la decisione vive
+      # in JobPerformance#record).
       initializer "closeyourit.sidekiq" do
         if defined?(::Sidekiq) && ::Sidekiq.respond_to?(:configure_server)
           ::Sidekiq.configure_server do |sidekiq_config|
             sidekiq_config.error_handlers << CloseYourIt::Sidekiq::ErrorHandler.new
+            sidekiq_config.server_middleware do |chain|
+              chain.add CloseYourIt::Sidekiq::JobMetricsMiddleware
+            end
           end
         end
       end

data/lib/closeyourit/rails/request_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "rack/utils"
+require_relative "../trace_context"
 
 module CloseYourIt
   module Rails
@@ -23,8 +23,13 @@ module CloseYourIt
 
       def call(env)
         if enabled?
-          # trace_id sempre (correlazione log↔errori), anche con capture_request OFF.
-          CloseYourIt::Scope.current.trace_id = trace_id_for(env)
+          # Contesto di trace W3C (solo con propagazione opt-in): adottato dall'header entrante o generato.
+          context = trace_context_for(env)
+          CloseYourIt::Scope.current.trace_context = context
+          # trace_id sempre (correlazione log↔errori), anche con capture_request OFF. Con un trace context
+          # W3C il trace_id degli eventi È il trace-id W3C → l'errore/metrica si allinea alla traccia
+          # distribuita propagata a valle (mapping trace_id, CYRB-15); altrimenti request_id come prima.
+          CloseYourIt::Scope.current.trace_id = context ? context.trace_id : trace_id_for(env)
           # Correlazione errore server ↔ session replay: l'id dal cookie finisce sullo scope
           # → contexts.replay.replay_id dell'evento (stesso punto del percorso JS).
           CloseYourIt::Scope.current.replay_session_id = replay_session_id_for(env)
@@ -47,6 +52,17 @@ module CloseYourIt
         false
       end
 
+      # Contesto di trace W3C della richiesta, SOLO con la propagazione opt-in attiva (altrimenti nil →
+      # comportamento storico invariato). Adotta un traceparent/tracestate entrante valido (correlazione
+      # distribuita), altrimenti genera un root: così anche i servizi che ORIGINANO traffico partono con
+      # un trace-id W3C propagabile a valle. Un traceparent malformato è ignorato → si genera un root.
+      def trace_context_for(env)
+        return nil unless CloseYourIt.configuration.propagate_trace_context
+
+        CloseYourIt::TraceContext.parse(env["HTTP_TRACEPARENT"], env["HTTP_TRACESTATE"]) ||
+          CloseYourIt::TraceContext.generate
+      end
+
       # Riusa il request id di Rails/Rack se presente (stessa correlazione dei log applicativi),
       # altrimenti ne genera uno.
       def trace_id_for(env)
@@ -60,6 +76,10 @@ module CloseYourIt
         cookie = env["HTTP_COOKIE"]
         return nil if cookie.nil? || cookie.empty?
 
+        # `rack/utils` caricato lazy: il middleware gira solo dentro un'app Rack (dove Rack c'è di
+        # sicuro), così `require "closeyourit-ruby"` non forza Rack in app non-web (CLI/worker) e la
+        # gemma resta installabile senza dichiarare `rack` tra le dipendenze (CYRB-13).
+        require "rack/utils"
         Rack::Utils.parse_cookies_header(cookie)[REPLAY_COOKIE].to_s.then { |id| id.empty? ? nil : id }
       end
 

data/lib/closeyourit/scope.rb

@@ -18,6 +18,13 @@ module CloseYourIt
         store[STORAGE_KEY] ||= new
       end
 
+      # Re-installa uno scope salvato in precedenza. Serve a `after_discard` (ActiveJob 7.1+) per
+      # riprendere lo scope arricchito durante il `perform` — tag/contesti/breadcrumb, incluse le query —
+      # dopo che il reset di fine `perform` l'ha sganciato dallo storage (CYRB-19). Simmetrico a `reset!`.
+      def current=(scope)
+        store[STORAGE_KEY] = scope
+      end
+
       # Azzera lo scope corrente — chiamato in `ensure` da middleware e job (su Puma il
       # thread è riusato: senza reset lo scope colerebbe nella richiesta successiva).
       def reset!
@@ -35,7 +42,7 @@ module CloseYourIt
       end
     end
 
-    attr_accessor :request, :trace_id, :rack_env, :replay_session_id
+    attr_accessor :request, :trace_id, :rack_env, :replay_session_id, :trace_context
     attr_reader :user, :tags, :extra, :contexts, :breadcrumbs
 
     def initialize
@@ -81,6 +88,9 @@ module CloseYourIt
       @rack_env    = nil
       @trace_id    = nil
       @replay_session_id = nil
+      # Contesto di trace W3C della richiesta (CloseYourIt::TraceContext): popolato solo con la
+      # propagazione opt-in attiva, consumato dal patch Net::HTTP per gli header d'uscita.
+      @trace_context = nil
       @breadcrumbs = BreadcrumbBuffer.new(CloseYourIt.configuration.max_breadcrumbs)
       @performance_profile = nil
     end

data/lib/closeyourit/sidekiq/job_metrics_middleware.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../subscribers/job_performance"
+
+module CloseYourIt
+  module Sidekiq
+    # Server middleware Sidekiq (registrato dal railtie solo se Sidekiq è presente) che misura la durata
+    # di esecuzione e l'attesa in coda del job, poi delega a Subscribers::JobPerformance l'emissione
+    # delle metriche oltre soglia. Non altera il job: cronometra attorno allo `yield` e ri-solleva
+    # qualunque errore invariato (la cattura degli errori è dell'ErrorHandler). La misurazione avviene
+    # nell'`ensure`, così è presa anche per i job che sollevano; la telemetria è isolata (un errore nel
+    # nostro codice non disturba mai il job ospite). No-op effettivo se `monitor_jobs` è OFF (la
+    # decisione vive in #record).
+    class JobMetricsMiddleware
+      def initialize(subscriber = nil)
+        @subscriber = subscriber
+      end
+
+      def call(_worker, job, queue)
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        # L'attesa in coda si conosce all'INIZIO (now - enqueued_at); Sidekiq mette enqueued_at come
+        # epoch in secondi. Calcolata prima dello yield per non includere la durata del job.
+        latency = Subscribers::JobPerformance.latency_ms(job["enqueued_at"], now: Time.now.utc)
+        yield
+      ensure
+        emit(job, queue, started, latency)
+      end
+
+      private
+
+      def emit(job, queue, started, latency)
+        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0
+        subscriber.record(
+          job_class: job["wrapped"] || job["class"],
+          queue: queue || job["queue"],
+          adapter: "sidekiq",
+          duration_ms: duration_ms,
+          queue_latency_ms: latency,
+          attempt: attempt(job),
+          trace_id: job["jid"]
+        )
+      rescue StandardError => e
+        CloseYourIt.internal_logger.error("CloseYourIt job metrics: #{e.class}: #{e.message}")
+      end
+
+      def subscriber
+        @subscriber ||= Subscribers::JobPerformance.new
+      end
+
+      # Numero di esecuzione 1-based. Sidekiq NON imposta `retry_count` al primo run (nil), lo porta a 0
+      # al primo retry, 1 al secondo, ... → attempt = retry_count + 2 quando presente, 1 al primo run.
+      def attempt(job)
+        count = job["retry_count"]
+        count.nil? ? 1 : count + 2
+      end
+    end
+  end
+end

data/lib/closeyourit/stats.rb

@@ -4,12 +4,14 @@ require "concurrent"
 
 module CloseYourIt
   # Contatori diagnostici thread-safe del client: quanti eventi sono stati accodati,
-  # scartati (coda piena), spediti con successo o falliti (rete o status non-2xx).
-  # Servono a rendere visibili i fallimenti silenziosi del trasporto fire-and-forget.
+  # scartati (coda piena / before_send / sampling), spediti con successo, falliti (rete o status
+  # non-2xx) e, tra i falliti, quanti per timeout di rete. Rendono visibili i fallimenti silenziosi
+  # del trasporto fire-and-forget. `timeout` è un sotto-conteggio di `failed` (un timeout resta un
+  # fallimento d'invio): li teniamo distinti per isolare i problemi di connettività dai non-2xx.
   #
-  #   CloseYourIt.stats.to_h # => { enqueued: 12, dropped: 0, sent: 11, failed: 1 }
+  #   CloseYourIt.stats.to_h # => { enqueued: 12, dropped: 0, sent: 11, failed: 1, timeout: 1 }
   class Stats
-    COUNTERS = %i[enqueued dropped sent failed].freeze
+    COUNTERS = %i[enqueued dropped sent failed timeout].freeze
 
     def initialize
       @counters = COUNTERS.to_h { |name| [ name, Concurrent::AtomicFixnum.new(0) ] }
@@ -29,6 +31,11 @@ module CloseYourIt
       @counters.transform_values(&:value)
     end
 
+    # Fotografia thread-safe dei contatori (ogni valore letto atomicamente). È lo stesso Hash di
+    # `to_h`, con un nome esplicito per il caso d'uso "leggo la diagnostica locale" (CYRB-12): pura
+    # lettura in-memory, non invia mai telemetria.
+    alias_method :snapshot, :to_h
+
     def reset!
       @counters.each_value { |counter| counter.value = 0 }
       self

data/lib/closeyourit/subscribers/job_performance.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../events/job_metric_event"
+
+module CloseYourIt
+  module Subscribers
+    # Misura durata di esecuzione e attesa in coda (queue latency) dei background job — ActiveJob e
+    # Sidekiq — e, oltre le soglie configurate, emette metriche performance_issue (subtype `slow_job`
+    # e `job_queue_latency`). Logica PURA e SENZA STATO condiviso: tutto arriva per parametri, quindi
+    # job concorrenti sullo stesso thread/processo non si contaminano. Il wiring ad
+    # ActiveSupport::Notifications e al middleware Sidekiq vive altrove (Railtie / JobMetricsMiddleware).
+    # Rispetta il master switch `monitor_jobs`, le soglie e il `jobs_sample_rate`.
+    class JobPerformance
+      def initialize(configuration = nil)
+        @configuration = configuration
+      end
+
+      # Punto unico di decisione: dai valori misurati (durata e/o attesa) costruisce 0..2 metriche,
+      # applica le soglie (stretto `>`, così X non genera rumore e X+1 sì) e il sampling, poi le spedisce
+      # fire-and-forget. `duration_ms` e `queue_latency_ms` sono opzionali: ActiveJob li fornisce da due
+      # hook distinti (perform_start → attesa, perform → durata), Sidekiq entrambi in una sola chiamata.
+      # Il sampling è applicato SOLO ai candidati già oltre soglia (i job normali non consumano né
+      # generano nulla).
+      def record(job_class:, queue: nil, adapter: nil, duration_ms: nil, queue_latency_ms: nil,
+                 attempt: nil, trace_id: nil)
+        config = configuration
+        return unless config.monitor_jobs
+
+        common = { job_class: job_class, queue: queue, adapter: adapter, attempt: attempt, trace_id: trace_id }
+        events = []
+        events << build(config, "slow_job", duration_ms, common) if slow?(config, duration_ms)
+        events << build(config, "job_queue_latency", queue_latency_ms, common) if waited?(config, queue_latency_ms)
+        return if events.empty?
+        return unless sampled?(config)
+
+        events.each { |event| CloseYourIt.capture_event(event) }
+        nil
+      end
+
+      # Hook `perform_start.active_job`: l'attesa in coda è nota appena il job parte (now - enqueued_at).
+      def active_job_started(job, now: Time.now.utc)
+        record(
+          job_class: job.class.name,
+          queue: (job.queue_name if job.respond_to?(:queue_name)),
+          adapter: "active_job",
+          queue_latency_ms: self.class.latency_ms(enqueued_at(job), now: now),
+          attempt: (job.executions if job.respond_to?(:executions)),
+          trace_id: (job.job_id if job.respond_to?(:job_id))
+        )
+      end
+
+      # Hook `perform.active_job`: a fine esecuzione la durata è `event.duration` (ms).
+      def active_job_performed(job, duration_ms)
+        record(
+          job_class: job.class.name,
+          queue: (job.queue_name if job.respond_to?(:queue_name)),
+          adapter: "active_job",
+          duration_ms: duration_ms,
+          attempt: (job.executions if job.respond_to?(:executions)),
+          trace_id: (job.job_id if job.respond_to?(:job_id))
+        )
+      end
+
+      # Normalizza `enqueued_at` (Time, epoch Numerico in secondi come Sidekiq, o String ISO8601) in
+      # attesa (ms) rispetto a `now`. nil o non parsabile → nil: nessuna metrica di attesa (adapter che
+      # non popola l'istante di enqueue). Clamp a 0 se negativa (clock skew, enqueue "nel futuro"): lo
+      # schema di ingest esige `duration_ms >= 0`.
+      def self.latency_ms(enqueued_at, now:)
+        started = to_time(enqueued_at)
+        return nil if started.nil?
+
+        ms = (now - started) * 1000.0
+        ms.negative? ? 0.0 : ms
+      end
+
+      def self.to_time(value)
+        case value
+        when Time    then value
+        when Numeric then Time.at(value)
+        when String  then parse_time(value)
+        end
+      end
+
+      def self.parse_time(value)
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+
+      private
+
+      def enqueued_at(job)
+        job.enqueued_at if job.respond_to?(:enqueued_at)
+      end
+
+      def configuration
+        @configuration || CloseYourIt.configuration
+      end
+
+      def slow?(config, duration_ms)
+        duration_ms && config.slow_job_threshold_ms && duration_ms > config.slow_job_threshold_ms
+      end
+
+      def waited?(config, latency_ms)
+        latency_ms && config.job_queue_latency_threshold_ms &&
+          latency_ms > config.job_queue_latency_threshold_ms
+      end
+
+      def sampled?(config)
+        rate = config.jobs_sample_rate.to_f
+        return true if rate >= 1.0
+        return false if rate <= 0.0
+
+        Random.rand < rate
+      end
+
+      def build(config, subtype, duration_ms, common)
+        JobMetricEvent.new(common.merge(subtype: subtype, duration_ms: duration_ms), config)
+      end
+    end
+  end
+end

data/lib/closeyourit/subscribers/slow_query.rb

@@ -21,6 +21,7 @@ module CloseYourIt
         config = @configuration || CloseYourIt.configuration
         return if ignored_name?(name)
         return if duration_ms < config.slow_query_threshold_ms
+        return if excluded_sql?(config, sql)
 
         event = SlowQueryEvent.new(
           { name: name, sql: sql, cached: cached, connection: connection,
@@ -77,6 +78,26 @@ module CloseYourIt
       def ignored_name?(name)
         name.nil? || IGNORED_NAMES.include?(name)
       end
+
+      # Query esclusa dalla MISURA dei rallentamenti (config.excluded_query_patterns). Il filtro sta
+      # solo qui, non in #breadcrumb né in #profile:
+      #
+      #   - breadcrumb: la cronologia "quali query prima del crash" ha valore diagnostico anche quando
+      #     la query è del framework — nasconderla renderebbe la sequenza incompleta e bugiarda;
+      #   - profile: è per-richiesta e serve la detection N+1, dove una tabella di servizio letta molte
+      #     volte è essa stessa un sintomo da vedere.
+      #
+      # Un rallentamento va misurato se qualcuno può intervenire; una breadcrumb va tenuta se aiuta a
+      # capire. Sono due domande diverse, e questa lista risponde solo alla prima.
+      def excluded_sql?(config, sql)
+        return false if sql.nil?
+
+        patterns = config.excluded_query_patterns
+        return false if patterns.empty?
+
+        text = sql.to_s
+        patterns.any? { |pattern| pattern.match?(text) }
+      end
     end
   end
 end

data/lib/closeyourit/trace_context.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module CloseYourIt
+  # Contesto di trace W3C (`traceparent`/`tracestate`, https://www.w3.org/TR/trace-context/).
+  # NON è un tracer: non apre span né misura tempi. È un "propagation bridge" minimale (il ticket:
+  # "Non costruire tracing custom completo") — adotta un contesto entrante valido facendo pass-through
+  # di trace-id/parent-id/flag, oppure ne genera uno root, e sa serializzarsi negli header d'uscita.
+  # Volutamente separato dai formati proprietari: sullo standard, senza dipendere da un vendor.
+  class TraceContext
+    # traceparent = version "-" trace-id "-" parent-id "-" trace-flags (55 char per la versione 00).
+    # `rest` cattura eventuali campi futuri: ammessi solo da versioni > 00 (forward-compat), vietati su 00.
+    TRACEPARENT = /
+      \A
+      (?<version>[0-9a-f]{2})-
+      (?<trace_id>[0-9a-f]{32})-
+      (?<parent_id>[0-9a-f]{16})-
+      (?<flags>[0-9a-f]{2})
+      (?<rest>-.*)?
+      \z
+    /x
+
+    FORBIDDEN_VERSION = "ff"
+    CURRENT_VERSION   = "00"
+    ZERO_TRACE_ID     = ("0" * 32).freeze
+    ZERO_PARENT_ID    = ("0" * 16).freeze
+    FLAG_SAMPLED      = 0x01
+
+    # tracestate: lista di membri `key=value` separati da virgola, max 32 (W3C §3.3.1).
+    TRACESTATE_MAX_MEMBERS = 32
+    # key: lowercase alnum iniziale + set ristretto (incluso `@`/`/` per le chiavi tenant@vendor).
+    # value: caratteri stampabili 0x20–0x7E esclusi `,` (0x2C) e `=` (0x3D).
+    TRACESTATE_MEMBER = %r{\A[a-z0-9][a-z0-9_\-*/@]*=[\x20-\x2b\x2d-\x3c\x3e-\x7e]+\z}
+
+    attr_reader :trace_id, :parent_id, :flags, :tracestate
+
+    def initialize(trace_id:, parent_id:, flags:, tracestate: nil)
+      @trace_id   = trace_id
+      @parent_id  = parent_id
+      @flags      = flags
+      @tracestate = tracestate
+    end
+
+    class << self
+      # Adotta un traceparent entrante. Ritorna nil se malformato (→ il chiamante genera un root o
+      # lascia il contesto assente). Pass-through: mantiene trace-id/parent-id/flag verbatim così il
+      # bridge non inventa span. Il tracestate viene sanificato (membri invalidi scartati, cap a 32).
+      def parse(traceparent, tracestate = nil)
+        match = TRACEPARENT.match(traceparent.to_s.strip)
+        return nil unless match
+        return nil if match[:version] == FORBIDDEN_VERSION
+        return nil if match[:version] == CURRENT_VERSION && match[:rest]
+        return nil if match[:trace_id] == ZERO_TRACE_ID
+        return nil if match[:parent_id] == ZERO_PARENT_ID
+
+        new(
+          trace_id:   match[:trace_id],
+          parent_id:  match[:parent_id],
+          flags:      match[:flags].to_i(16),
+          tracestate: sanitize_tracestate(tracestate)
+        )
+      end
+
+      # Nuovo contesto root (nessun traceparent entrante valido). Genera trace-id (16 byte) e parent-id
+      # (8 byte) casuali — SecureRandom è fork-safe, così un worker forkato non riusa gli id del padre.
+      # `sampled` fissa il flag: un root che apriamo noi traccia di default.
+      def generate(sampled: true)
+        new(
+          trace_id:   SecureRandom.hex(16),
+          parent_id:  SecureRandom.hex(8),
+          flags:      sampled ? FLAG_SAMPLED : 0,
+          tracestate: nil
+        )
+      end
+
+      private
+
+      # Trattiene solo i membri ben formati, nell'ordine originale, fino a 32. Ritorna nil se non ne
+      # resta nessuno → così non propaghiamo mai un tracestate spazzatura o sovradimensionato.
+      def sanitize_tracestate(tracestate)
+        return nil if tracestate.nil?
+
+        valid = tracestate.to_s.split(",").map(&:strip)
+                          .select { |member| TRACESTATE_MEMBER.match?(member) }
+                          .first(TRACESTATE_MAX_MEMBERS)
+        valid.empty? ? nil : valid.join(",")
+      end
+    end
+
+    def sampled?
+      (flags & FLAG_SAMPLED) != 0
+    end
+
+    # traceparent d'uscita, sempre versione 00 (l'unica che sappiamo emettere). I flag sono ri-emessi
+    # per intero (i bit riservati vanno propagati as-is), formattati su due cifre esadecimali.
+    def traceparent
+      format("%s-%s-%s-%02x", CURRENT_VERSION, trace_id, parent_id, flags & 0xff)
+    end
+
+    # Header di propagazione W3C: traceparent (+ tracestate se presente). MAI `baggage`: può contenere
+    # contesto interno/PII e non deve varcare il confine (ticket: "baggage sensibile non riceve header").
+    def headers
+      result = { "traceparent" => traceparent }
+      result["tracestate"] = tracestate if tracestate && !tracestate.empty?
+      result
+    end
+  end
+end

data/lib/closeyourit/transport.rb

@@ -3,6 +3,7 @@
 require "net/http"
 require "json"
 require "uri"
+require "timeout"
 
 module CloseYourIt
   # Spedisce un payload a un path di ingest (errori → /events, metriche → /metrics) via HTTP POST
@@ -14,6 +15,10 @@ module CloseYourIt
     # Ri-POSTiamo a Location preservando metodo + body, così l'evento non si perde in silenzio.
     MAX_REDIRECTS = 2
 
+    # Un timeout di rete (apertura o lettura) è un fallimento d'invio speciale: lo isoliamo dai non-2xx
+    # e dagli altri errori di rete perché segnala tipicamente problemi di connettività (CYRB-12).
+    TIMEOUT_ERRORS = [ Net::OpenTimeout, Net::ReadTimeout, Timeout::Error ].freeze
+
     def initialize(configuration)
       @configuration = configuration
     end
@@ -22,19 +27,31 @@ module CloseYourIt
       response = post(payload, path)
       if response.is_a?(Net::HTTPSuccess)
         CloseYourIt.stats.increment(:sent)
+        CloseYourIt.notify_diagnostic(:send, status: response.code.to_i)
       else
         CloseYourIt.stats.increment(:failed)
         CloseYourIt.internal_logger.warn("CloseYourIt transport: HTTP #{response.code}#{error_detail(response)} su #{path}")
+        CloseYourIt.notify_diagnostic(:drop, reason: :response, status: response.code.to_i)
       end
       response
     rescue StandardError => e
       CloseYourIt.stats.increment(:failed)
       CloseYourIt.internal_logger.error("CloseYourIt transport: #{e.class}: #{e.message}")
+      if timeout_error?(e)
+        CloseYourIt.stats.increment(:timeout)
+        CloseYourIt.notify_diagnostic(:timeout, error: e.class.name)
+      else
+        CloseYourIt.notify_diagnostic(:drop, reason: :network, error: e.class.name)
+      end
       nil
     end
 
     private
 
+    def timeout_error?(error)
+      TIMEOUT_ERRORS.any? { |klass| error.is_a?(klass) }
+    end
+
     def post(payload, path)
       body = JSON.generate(payload)
       origin = URI.parse("#{base_url}#{path}")

data/lib/closeyourit/version.rb

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