closeyourit-ruby 0.9.4 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1d5e126aa96c17501b6830b9c7763979c239cd4bf4b0e0d43685b0652025378
-  data.tar.gz: c2d52c988da1288a5cea2986261481ec87fd67db8f3fb0921e2161c90653022e
+  metadata.gz: 0bc659e436ad9b08b9861d4898e6876a3b753ec88ebb7f8e81075729d958fcb4
+  data.tar.gz: 2bb509651ce4aa880a40f2d49f29c9584bb1bfde984b6fba3065c1a954800f82
 SHA512:
-  metadata.gz: e9b3c6b9d352ad92055e710951157956c6fa3a75c8cbcee6bf6f9dbdbd3eb829ac6c990f54a38a72ef141c2e8d5a71eb714905355cbeee7be94a3957d6f6b22e
-  data.tar.gz: 6bc37b84e2d6a19e6690df0c40732df11fcf32069f1c9942f2d2ddbf6bb76cedb29a94e86c6fd4269002c9f0f9a4c352c53e1c0b41da9a32f5588503ad645b45
+  metadata.gz: d3cfd52ac4b7ddda5a5a92485ebe1fb4be25b808e706b11af7c5e0c6767fff19af3aa3958a8a3d9e6d94ec6ec36162a942fa439700bd16d07d52987d34a4328e
+  data.tar.gz: fe22c4cae5a0e94f4eeaf8284d00c0a42d51a0d8c3830dcd703abcf9774eaf31c4e5e81c0c4b8ba6331a1e3d331078136b2cf05e09316325c5f545acaa8b9c17

data/README.md

@@ -79,6 +79,7 @@ end
 | `before_send` | `nil` | `->(payload) { ... }` — scrub finale; ritorna payload o `nil` per scartare |
 | `sample_rate` | `1.0` | Frazione di errori/messaggi inviata (`1.0` tutto, `0.0` niente) |
 | `async_threads` | `cpu/2` | Thread di invio; `0` = sincrono (test) |
+| `shutdown_timeout` | `15` | Secondi di attesa, alla chiusura, perché gli invii in volo completino; scaduto il tempo gli eventi residui sono contati come `dropped` (vedi [Flush di fine-vita](#flush-di-fine-vita)) |
 | `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 |
@@ -227,6 +228,11 @@ 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.
 
+Il drain attende fino a `shutdown_timeout` secondi (default `15`, il tetto di durata di una singola
+POST verso l'ingest). Gli eventi ancora in coda quando il tempo scade sono contati come `dropped`
+nello snapshot diagnostico di fine-vita: nessuna perdita silenziosa. Abbassa il valore se l'uscita
+del processo deve essere più rapida della consegna.
+
 #### Server che forkano (Puma cluster, Sidekiq, Unicorn)
 
 I server che precaricano l'app (`preload_app!`) inizializzano la gemma nel processo **master**, poi

data/lib/closeyourit/background_worker.rb

@@ -32,15 +32,34 @@ module CloseYourIt
       accepted
     end
 
-    def shutdown(timeout = 1)
+    # Drena la coda attendendo fino a `timeout` secondi. Il default è il tetto di durata di UNA POST
+    # (Transport::MAX_REQUEST_SECONDS): aspettare meno abbandona invii ancora sani, ed è quello che
+    # succedeva con il vecchio secondo fisso (CYRB-24). Se il drain scade, i task rimasti in coda sono
+    # persi: contali come `dropped`, altrimenti lo snapshot di fine vita dichiara zero perdite.
+    def shutdown(timeout = Transport::MAX_REQUEST_SECONDS)
       return unless @executor.respond_to?(:shutdown)
 
       @executor.shutdown
-      @executor.wait_for_termination(timeout)
+      terminated = @executor.wait_for_termination(timeout)
+      report_abandoned(timeout) unless terminated
+      terminated
     end
 
     private
 
+    # Task accodati e mai eseguiti al momento della scadenza del drain. `queue_length` non esiste
+    # sull'ImmediateExecutor (sincrono, niente coda) → zero residui.
+    def report_abandoned(timeout)
+      abandoned = @executor.respond_to?(:queue_length) ? @executor.queue_length.to_i : 0
+      CloseYourIt.internal_logger.warn(
+        "CloseYourIt background worker: drain scaduto dopo #{timeout}s, #{abandoned} eventi abbandonati"
+      )
+      abandoned.times do
+        CloseYourIt.stats.increment(:dropped)
+        CloseYourIt.notify_diagnostic(:drop, reason: :shutdown_timeout)
+      end
+    end
+
     def build_executor(threads, max_queue)
       return Concurrent::ImmediateExecutor.new if threads <= 0
 

data/lib/closeyourit/client.rb

@@ -54,17 +54,7 @@ module CloseYourIt
     def flush_logs(events)
       return nil if events.nil? || events.empty?
 
-      payloads = events.map(&:to_h)
-      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
+      payloads = events.filter_map { |event| build_log_payload(event) }
       return nil if payloads.empty?
 
       path = events.first.ingest_path(@configuration.project_id)
@@ -95,7 +85,30 @@ module CloseYourIt
     end
 
     def shutdown
-      @worker.shutdown
+      @worker.shutdown(@configuration.shutdown_timeout)
+    end
+
+    private
+
+    # Costruisce il payload di UNA voce di log. `to_h` (scrubber su un byte non UTF-8) e `before_send`
+    # possono sollevare: qui il buffer è già stato drenato, quindi una sola voce rotta valutata
+    # insieme alle altre porterebbe via l'intero batch di voci sane. Ogni voce è isolata e scartata
+    # da sola, come fa il client JS (CYRB-24). `nil` = voce da non spedire, già contabilizzata.
+    def build_log_payload(event)
+      payload = event.to_h
+      payload = @configuration.before_send.call(payload) if @configuration.before_send
+      return payload unless payload.nil?
+
+      # Scarto voluto di before_send: contabilizzato come in #capture_event, altrimenti sparirebbe
+      # silenziosamente dai contatori (CYRB-12).
+      CloseYourIt.stats.increment(:dropped)
+      CloseYourIt.notify_diagnostic(:drop, reason: :before_send)
+      nil
+    rescue StandardError => e
+      CloseYourIt.internal_logger.error("CloseYourIt client: log scartato — #{e.class}: #{e.message}")
+      CloseYourIt.stats.increment(:dropped)
+      CloseYourIt.notify_diagnostic(:drop, reason: :error, error: e.class.name)
+      nil
     end
   end
 end

data/lib/closeyourit/configuration.rb

@@ -27,7 +27,7 @@ module CloseYourIt
     ].freeze
 
     attr_accessor :endpoint_url, :token, :project_id, :environment, :before_send, :on_diagnostic,
-                  :async_threads, :background_worker_max_queue,
+                  :async_threads, :background_worker_max_queue, :shutdown_timeout,
                   :slow_query_threshold_ms, :slow_method_threshold_ms,
                   :send_pii, :obfuscate_sql, :send_server_name,
                   :capture_query_bindings, :capture_method_arguments,
@@ -65,6 +65,10 @@ module CloseYourIt
 
       @async_threads               = default_threads
       @background_worker_max_queue  = 30
+      # Quanto attendere, alla chiusura del processo, che gli invii in volo completino. Default: il
+      # tetto di durata di UNA POST, così l'ultimo batch non viene abbandonato a metà (CYRB-24).
+      # Abbassalo se l'uscita del processo deve essere più rapida della consegna.
+      @shutdown_timeout = Transport::MAX_REQUEST_SECONDS
 
       # Intercetta SIGTERM per garantire il flush di fine-vita (deploy/Kamal): SIGTERM di default
       # termina il processo SENZA eseguire gli at_exit. OPT-IN perché sovrascrive un eventuale handler

data/lib/closeyourit/instrumenter.rb

@@ -13,8 +13,16 @@ module CloseYourIt
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       yield
     ensure
-      duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
-      report(label, duration_ms, location, args: args, kwargs: kwargs)
+      # `measure` gira DENTRO il metodo dell'app (Monitor fa prepend): un guasto qui — soglia non
+      # configurata, ingest irraggiungibile — solleverebbe in un chiamante che aveva già il suo
+      # risultato. È l'unico ingresso della gemma che era scoperto: ora è come tutti gli altri
+      # (CYRB-24). Un'eccezione del blocco misurato continua invece a propagare intatta.
+      begin
+        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
+        report(label, duration_ms, location, args: args, kwargs: kwargs)
+      rescue StandardError => e
+        CloseYourIt.internal_logger.error("CloseYourIt instrumenter: #{e.class}: #{e.message}")
+      end
     end
 
     def report(label, duration_ms, location = nil, args: nil, kwargs: nil)

data/lib/closeyourit/transport.rb

@@ -15,6 +15,11 @@ module CloseYourIt
     # Ri-POSTiamo a Location preservando metodo + body, così l'evento non si perde in silenzio.
     MAX_REDIRECTS = 2
 
+    # Durata massima di UNA send_event: apertura + lettura, ripetute a ogni redirect seguito. È il
+    # tetto che il drain di fine vita deve poter aspettare, altrimenti abbandona un invio ancora sano
+    # (CYRB-24).
+    MAX_REQUEST_SECONDS = (OPEN_TIMEOUT + READ_TIMEOUT) * (MAX_REDIRECTS + 1)
+
     # 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

data/lib/closeyourit/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closeyourit-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.10.0
 platform: ruby
 authors:
 - Alessio Bussolari