closeyourit-ruby 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d98365053459eaded9732014e987b01e3fcf2ac60a21db83026243d076bc2dbf
-  data.tar.gz: 4cb2024f4681e57d415097b8af237156f3cc0c8b764a2d14ea958bb8824e1738
+  metadata.gz: 82202d393845e74a379b6470a2f5f1c9e093d70840669266fb86624edd326c48
+  data.tar.gz: 7a302acfe53c9e0eb866ba407e9133bb63681c3d365126abdbf55368527ab7e4
 SHA512:
-  metadata.gz: de2f19a59df8c78825e0070e5c48c97424a7481d314219da675543da1ab71171ecfe7d5cd09cc0d81d48323be6d50435027e8a6bf901f121c6f5f3435b419b0d
-  data.tar.gz: 75ab998c2d1049bdcc047a96a54a01fe92cb50b820e81d1eac3795f4695416d7076956aac3defd82c520daaffd2dccf3726bb585cc189fb76090601928b3447f
+  metadata.gz: b85ebd77af24ee4aaa41ab447ba434be2ac3892c0ba4c7b09cf5a39069aca91ddb649a179ef621d72c263449452dcb5942c82df5449cd17e37a3494c374b8ed0
+  data.tar.gz: 037b9982aad55978b4c124d0751da800983327d18d8786228d8bbd00233f913a0e6ef8dd7e741c06307f11ed425ba2e37b8eae9dc985fba7c2067a9cbafda7fa

data/lib/closeyourit/background_worker.rb

@@ -20,12 +20,12 @@ module CloseYourIt
         block.call
       rescue Exception => e # rubocop:disable Lint/RescueException
         # Mai propagare: la telemetria non deve poter crashare l'app ospite.
-        CloseYourIt.logger.error("CloseYourIt background worker: #{e.class}: #{e.message}")
+        CloseYourIt.internal_logger.error("CloseYourIt background worker: #{e.class}: #{e.message}")
       end
 
       unless accepted
         CloseYourIt.stats.increment(:dropped)
-        CloseYourIt.logger.warn("CloseYourIt background worker: coda piena, evento scartato")
+        CloseYourIt.internal_logger.warn("CloseYourIt background worker: coda piena, evento scartato")
       end
 
       accepted

data/lib/closeyourit/client.rb

@@ -4,6 +4,11 @@ module CloseYourIt
   # Compone Transport + BackgroundWorker: applica `before_send` e dispatcha
   # l'invio in modo fire-and-forget.
   class Client
+    # Tetto di log per singola richiesta a /logs. Il backend rifiuta un batch oltre questo limite
+    # (413 R413-LOG-002) scartando l'INTERA richiesta — e il buffer è già stato drenato → log persi.
+    # Deve restare ≤ del limite server (LOGS_MAX_BATCH backend = 1000). Vedi #flush_logs.
+    LOGS_MAX_BATCH = 1000
+
     def initialize(configuration)
       @configuration = configuration
       @transport = Transport.new(configuration)
@@ -24,6 +29,25 @@ module CloseYourIt
       payload
     end
 
+    # Invia un batch di log come ARRAY a /logs (l'endpoint accetta singolo o array). before_send è
+    # applicato a ciascun payload; quelli scartati (nil) non vengono inviati. I payload oltre
+    # LOGS_MAX_BATCH sono spezzati in più POST sequenziali (un chunk = un POST), così un flush grande
+    # non viene rigettato in blocco dal backend e perso — vedi R3 / LOGS_MAX_BATCH. Un flush entro il
+    # limite resta un singolo POST.
+    def flush_logs(events)
+      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
+      return nil if payloads.empty?
+
+      path = events.first.ingest_path(@configuration.project_id)
+      payloads.each_slice(LOGS_MAX_BATCH) do |chunk|
+        @worker.perform { @transport.send_event(chunk, path: path) }
+      end
+      payloads
+    end
+
     def shutdown
       @worker.shutdown
     end

data/lib/closeyourit/configuration.rb

@@ -22,7 +22,9 @@ module CloseYourIt
                   :capture_query_bindings, :capture_method_arguments,
                   :capture_request, :request_header_allowlist,
                   :breadcrumbs_enabled, :max_breadcrumbs, :sample_rate,
-                  :capture_handled_errors, :report_active_job_errors
+                  :capture_handled_errors, :report_active_job_errors,
+                  :logs_enabled, :logs_sample_rate, :logs_batch_size, :logs_flush_interval,
+                  :capture_rails_logs, :logs_min_level
     attr_writer :release
     attr_reader :excluded_exceptions, :filter_parameters, :scrub_message_patterns
 
@@ -65,6 +67,15 @@ module CloseYourIt
       @capture_query_bindings   = false
       @capture_method_arguments = false
 
+      # Log strutturati (CloseYourIt.log / .logger). Master switch + sampling + batching dedicati.
+      @logs_enabled        = true
+      @logs_sample_rate    = 1.0
+      @logs_batch_size     = 50
+      @logs_flush_interval = 5
+      # Broadcast opt-in di Rails.logger → CloseYourIt.log (default OFF; spedisce solo ≥ soglia).
+      @capture_rails_logs = false
+      @logs_min_level     = :info
+
       @filter_parameters      = []
       @scrub_message_patterns = []
     end
@@ -98,9 +109,9 @@ module CloseYourIt
     # Logga i warning di configurazione (es. endpoint http://, project_id/endpoint malformati).
     # Non solleva mai: coerente con la filosofia no-op del client. Chiamata da `CloseYourIt.init`.
     def validate!
-      CloseYourIt.logger.warn(insecure_endpoint_message) if insecure_endpoint?
-      CloseYourIt.logger.warn(malformed_project_id_message) if malformed_project_id?
-      CloseYourIt.logger.warn(malformed_endpoint_message) if malformed_endpoint?
+      CloseYourIt.internal_logger.warn(insecure_endpoint_message) if insecure_endpoint?
+      CloseYourIt.internal_logger.warn(malformed_project_id_message) if malformed_project_id?
+      CloseYourIt.internal_logger.warn(malformed_endpoint_message) if malformed_endpoint?
       self
     end
 

data/lib/closeyourit/events/error_event.rb

@@ -29,6 +29,8 @@ module CloseYourIt
         "timestamp" => @occurred_at,
         "platform" => "ruby",
         "level" => @level,
+        # Correlazione log↔errori: stesso trace_id dei log della medesima richiesta (popolato dallo Scope).
+        "trace_id" => CloseYourIt::Scope.current.trace_id,
         "environment" => environment,
         "release" => @configuration.release,
         "server_name" => server_name,

data/lib/closeyourit/events/log_event.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module CloseYourIt
+  # Voce di log strutturata spedita all'ingest /logs (NON formato Sentry: i log sono uno stream con
+  # message/level/attributes/logger). Gli `attributes` passano dallo Scrubber (denylist). `trace_id`
+  # è preso dallo Scope corrente (popolato per richiesta) → correlazione log↔errori della stessa request.
+  class LogEvent < Event
+    # Livelli canonici del backend (enum) + alias dei nomi stile ::Logger. Normalizzati QUI (fonte
+    # unica) così ogni costruzione — via CloseYourIt.log, .logger o diretta — produce un livello valido.
+    LEVELS = %w[debug info warning error fatal].freeze
+    LEVEL_ALIASES = { "warn" => "warning", "err" => "error", "unknown" => "fatal" }.freeze
+
+    def initialize(message, level:, attributes:, configuration:, logger: nil)
+      super(configuration)
+      @message = message
+      @level = normalize_level(level)
+      @attributes = attributes || {}
+      @logger = logger
+    end
+
+    def to_h
+      compact(
+        "event_id" => SecureRandom.uuid.delete("-"),
+        "timestamp" => @occurred_at,
+        "level" => @level,
+        "message" => @message.to_s,
+        "attributes" => scrubbed_attributes,
+        "logger" => @logger,
+        "trace_id" => CloseYourIt::Scope.current.trace_id,
+        "environment" => environment,
+        "release" => @configuration.release,
+        "sdk" => sdk
+      )
+    end
+
+    def ingest_path(project_id)
+      "/api/v1/projects/#{project_id}/logs"
+    end
+
+    private
+
+    def normalize_level(level)
+      value = level.to_s.downcase
+      value = LEVEL_ALIASES.fetch(value, value)
+      LEVELS.include?(value) ? value : "info"
+    end
+
+    def scrubbed_attributes
+      return {} if @attributes.nil? || @attributes.empty?
+
+      Scrubber.new(@configuration).filter_params(deep_stringify_keys(@attributes))
+    end
+
+    # Chiavi sempre stringa (anche annidate): coerenza col payload JSON e con la denylist dello Scrubber.
+    def deep_stringify_keys(value)
+      case value
+      when Hash  then value.each_with_object({}) { |(key, val), acc| acc[key.to_s] = deep_stringify_keys(val) }
+      when Array then value.map { |item| deep_stringify_keys(item) }
+      else value
+      end
+    end
+  end
+end

data/lib/closeyourit/log_buffer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module CloseYourIt
+  # Buffer in-memory thread-safe dei log: accumula i LogEvent e li flusha in batch verso /logs quando
+  # raggiungono `logs_batch_size`, allo scadere di `logs_flush_interval` (timer), o allo shutdown.
+  # Riduce le richieste HTTP — i log sono alto-volume, a differenza di errori/metriche uno-a-uno.
+  class LogBuffer
+    attr_reader :timer # esposto per i test (verifica dell'intervallo configurato)
+
+    def initialize(client:, configuration:)
+      @client = client
+      @configuration = configuration
+      @mutex = Mutex.new
+      @events = []
+      @timer = nil
+    end
+
+    def add(event)
+      reached_batch = false
+      @mutex.synchronize do
+        @events << event
+        ensure_timer
+        reached_batch = @events.size >= @configuration.logs_batch_size.to_i
+      end
+      flush if reached_batch
+    end
+
+    def flush
+      batch = drain
+      return if batch.empty?
+
+      @client.flush_logs(batch)
+    end
+
+    def shutdown
+      @timer&.shutdown
+      flush
+    end
+
+    private
+
+    def drain
+      @mutex.synchronize do
+        events = @events
+        @events = []
+        events
+      end
+    end
+
+    # Avvia il timer di flush periodico alla prima voce (una sola volta).
+    def ensure_timer
+      return if @timer
+
+      interval = @configuration.logs_flush_interval.to_f
+      return if interval <= 0
+
+      @timer = Concurrent::TimerTask.new(execution_interval: interval) { flush }
+      @timer.execute
+    end
+  end
+end

data/lib/closeyourit/log_device.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  # Oggetto Logger-compatibile esposto come `CloseYourIt.logger`: ogni chiamata inoltra a
+  # `CloseYourIt.log` (→ ingest /logs). Usabile come logger esplicito dell'app, anche con attributes:
+  #   CloseYourIt.logger.warn("disco quasi pieno", disk: "sda1")
+  # `warn` mappa sul livello `warning` (enum backend); supporta block e `::Logger#add` per drop-in.
+  class LogDevice
+    # Severità numeriche ::Logger → livelli CloseYourIt (UNKNOWN→fatal).
+    SEVERITY_LEVELS = { 0 => "debug", 1 => "info", 2 => "warning", 3 => "error", 4 => "fatal", 5 => "fatal" }.freeze
+
+    def debug(message = nil, **attributes, &block) = write("debug", message, attributes, &block)
+    def info(message = nil, **attributes, &block)  = write("info", message, attributes, &block)
+    def warn(message = nil, **attributes, &block)  = write("warning", message, attributes, &block)
+    def error(message = nil, **attributes, &block) = write("error", message, attributes, &block)
+    def fatal(message = nil, **attributes, &block) = write("fatal", message, attributes, &block)
+
+    def <<(message)
+      write("info", message, {})
+      message
+    end
+
+    # Compat con ::Logger#add(severity, message = nil, progname = nil).
+    def add(severity, message = nil, progname = nil, &block)
+      write(SEVERITY_LEVELS.fetch(severity.to_i, "info"), message || progname, {}, &block)
+    end
+    alias log add
+
+    private
+
+    def write(level, message, attributes, &block)
+      # Gate PRIMA del block: `logger.debug { dump_costoso }` non valuta il block se i log sono spenti.
+      return unless CloseYourIt.logs_active?
+
+      message = block.call if block
+      CloseYourIt.log(level, message, **attributes)
+    end
+  end
+end

data/lib/closeyourit/rails/log_broadcast.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module CloseYourIt
+  module Rails
+    # Sink Logger-compatibile agganciato a Rails.logger (broadcast opt-in, `config.capture_rails_logs`):
+    # ogni log dell'app ≥ soglia (`logs_min_level`) viene re-inoltrato a CloseYourIt.log → ingest /logs.
+    # Sotto soglia: no-op (nessun invio). Non scrive su alcun device (inoltra soltanto).
+    class LogBroadcast < ::Logger
+      SEVERITY_LEVELS = { 0 => "debug", 1 => "info", 2 => "warning", 3 => "error", 4 => "fatal", 5 => "fatal" }.freeze
+      LEVEL_BY_SYMBOL = { debug: 0, info: 1, warn: 2, warning: 2, error: 3, fatal: 4 }.freeze
+
+      def initialize(min_level = :info)
+        super(nil) # nessun device: inoltra soltanto
+        self.level = LEVEL_BY_SYMBOL.fetch(min_level.to_sym, 1)
+      end
+
+      # Sovrascrive il punto unico di ::Logger: filtra per soglia e re-inoltra a CloseYourIt.log.
+      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?
+        true
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/railtie.rb

@@ -6,6 +6,7 @@ require_relative "active_job_extension"
 require_relative "error_subscriber"
 require_relative "../sidekiq/error_handler"
 require_relative "query_source"
+require_relative "log_broadcast"
 require_relative "../subscribers/slow_query"
 
 module CloseYourIt
@@ -61,6 +62,15 @@ module CloseYourIt
         end
       end
 
+      # 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
+        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))
+        end
+      end
+
       # Cattura gli errori dei job Sidekiq (solo se Sidekiq è presente).
       initializer "closeyourit.sidekiq" do
         if defined?(::Sidekiq) && ::Sidekiq.respond_to?(:configure_server)

data/lib/closeyourit/rails/request_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module CloseYourIt
   module Rails
     # Rack middleware: popola lo Scope con il contesto HTTP della richiesta (method/url/header)
@@ -15,7 +17,11 @@ module CloseYourIt
       end
 
       def call(env)
-        CloseYourIt::Scope.current.request = build_request(env) if active?
+        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
+        end
         @app.call(env)
       ensure
         CloseYourIt::Scope.reset!
@@ -23,12 +29,20 @@ module CloseYourIt
 
       private
 
-      def active?
-        CloseYourIt.enabled? && CloseYourIt.configuration.capture_request
+      def enabled?
+        CloseYourIt.enabled?
       rescue StandardError
         false
       end
 
+      # Riusa il request id di Rails/Rack se presente (stessa correlazione dei log applicativi),
+      # altrimenti ne genera uno.
+      def trace_id_for(env)
+        env["action_dispatch.request_id"] ||
+          env["HTTP_X_REQUEST_ID"].to_s.split(",").first&.strip.then { |id| id&.empty? ? nil : id } ||
+          SecureRandom.uuid
+      end
+
       # Forma `request` Sentry. URL senza query string; header solo dall'allowlist (mai
       # Authorization/Cookie). query_string + IP solo con send_pii (opt-in).
       def build_request(env)

data/lib/closeyourit/scope.rb

@@ -34,7 +34,7 @@ module CloseYourIt
       end
     end
 
-    attr_accessor :request
+    attr_accessor :request, :trace_id
     attr_reader :user, :tags, :extra, :contexts, :breadcrumbs
 
     def initialize
@@ -71,17 +71,20 @@ module CloseYourIt
       @extra       = {}
       @contexts    = {}
       @request     = nil
+      @trace_id    = nil
       @breadcrumbs = BreadcrumbBuffer.new(CloseYourIt.configuration.max_breadcrumbs)
     end
 
     # Sottoinsieme non vuoto in forma evento Sentry (user/tags/extra/contexts/request),
-    # fuso nel payload da ErrorEvent#to_h.
+    # fuso nel payload da ErrorEvent#to_h. tags/extra/contexts passano dallo Scrubber (denylist
+    # ricorsiva per chiave): il backend NON li ri-scruba (Errors::Ingest::Normalize li conserva
+    # verbatim), quindi questa è l'unica rete di sicurezza contro le chiavi sensibili lì — R2.
     def to_event_hash
       {
         "user"        => serialize_user,
-        "tags"        => presence(@tags),
-        "extra"       => presence(@extra),
-        "contexts"    => presence(@contexts),
+        "tags"        => scrub(presence(@tags)),
+        "extra"       => scrub(presence(@extra)),
+        "contexts"    => scrub(presence(@contexts)),
         "request"     => @request,
         "breadcrumbs" => breadcrumbs_payload
       }.reject { |_key, value| value.nil? }
@@ -89,6 +92,15 @@ module CloseYourIt
 
     private
 
+    # Redige i valori delle chiavi sensibili preservando la struttura (es. contexts.runtime resta
+    # intatto, solo i valori sotto chiavi sensibili diventano [FILTERED]). Riusa lo Scrubber della
+    # configurazione, lo stesso percorso di breadcrumb.data e degli attributi di log.
+    def scrub(hash)
+      return hash if hash.nil?
+
+      Scrubber.new(CloseYourIt.configuration).filter_params(hash)
+    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/scrubber.rb

@@ -6,10 +6,14 @@ module CloseYourIt
   class Scrubber
     FILTERED = "[FILTERED]"
 
-    # Token di chiavi sempre redatti (match per sottostringa, normalizzato).
+    # Token di chiavi sempre redatti (match per sottostringa, normalizzato). Allineato 1:1 al regex
+    # di backend e client Dart (parità client-side) — vedi Errors/Logs::Ingest::Normalize::SENSITIVE_KEY:
+    #   /pass|secret|token|api[_-]?key|apikey|authorization|cookie|csrf|credit|card|cvv|ssn|iban/i
+    # `pass` copre password/passwd/pass_code/passkey/passphrase; `cookie` copre set-cookie;
+    # `credit`+`card` coprono credit_card. La lista letterale precedente ometteva i `pass*` bare → leak.
     DENYLIST = %w[
-      password passwd secret token api_key apikey authorization
-      cookie set-cookie csrf credit_card card cvv ssn iban
+      pass secret token api_key apikey authorization
+      cookie csrf credit card cvv ssn iban
     ].freeze
 
     STRING_LITERAL = /'(?:[^']|'')*'/

data/lib/closeyourit/transport.rb

@@ -24,12 +24,12 @@ module CloseYourIt
         CloseYourIt.stats.increment(:sent)
       else
         CloseYourIt.stats.increment(:failed)
-        CloseYourIt.logger.warn("CloseYourIt transport: HTTP #{response.code} su #{path}")
+        CloseYourIt.internal_logger.warn("CloseYourIt transport: HTTP #{response.code} su #{path}")
       end
       response
     rescue StandardError => e
       CloseYourIt.stats.increment(:failed)
-      CloseYourIt.logger.error("CloseYourIt transport: #{e.class}: #{e.message}")
+      CloseYourIt.internal_logger.error("CloseYourIt transport: #{e.class}: #{e.message}")
       nil
     end
 

data/lib/closeyourit/version.rb

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

data/lib/closeyourit-ruby.rb

@@ -15,12 +15,16 @@ require_relative "closeyourit/events/error_event"
 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/log_device"
+require_relative "closeyourit/log_buffer"
 require_relative "closeyourit/subscribers/slow_query"
 require_relative "closeyourit/instrumenter"
 require_relative "closeyourit/monitor"
 require_relative "closeyourit/client"
 require_relative "closeyourit/rails/capture_exceptions"
 require_relative "closeyourit/rails/request_context"
+require_relative "closeyourit/rails/log_broadcast"
 require_relative "closeyourit/rails/active_job_extension"
 require_relative "closeyourit/rails/error_subscriber"
 require_relative "closeyourit/sidekiq/error_handler"
@@ -41,8 +45,10 @@ module CloseYourIt
     def init
       @configuration = Configuration.new
       @client = nil
+      @log_buffer = nil
       yield(@configuration) if block_given?
       @configuration.validate!
+      register_shutdown_flush
       @configuration
     end
 
@@ -139,11 +145,46 @@ module CloseYourIt
       )
     end
 
+    # Logger interno della gemma (warning/errori diagnostici su stdout). NON è il logging applicativo:
+    # per spedire log strutturati a CloseYourIt usa `CloseYourIt.log` / `CloseYourIt.logger`.
+    def internal_logger
+      @internal_logger ||= default_internal_logger
+    end
+
+    attr_writer :internal_logger
+
+    # Logger applicativo Logger-compatibile: inoltra ogni messaggio a `CloseYourIt.log` (→ ingest /logs).
+    #   CloseYourIt.logger.info("ordine creato", order_id: 1)
     def logger
-      @logger ||= default_logger
+      @app_logger ||= LogDevice.new
     end
 
-    attr_writer :logger
+    # Costruisce e bufferizza una voce di log strutturata (batch verso /logs, fire-and-forget). Il
+    # `level` è normalizzato ai livelli canonici (`:warn`→`warning`, downcase; ignoto→`info`). `logger`
+    # opzionale = nome della sorgente del log.
+    #   CloseYourIt.log(:info, "ordine creato", order_id: 1)
+    #   CloseYourIt.log(:warn, "retry", logger: "payments", attempt: 3)
+    def log(level, message, logger: nil, **attributes)
+      return nil unless logs_enabled?
+      return nil unless logs_sampled?
+
+      event = LogEvent.new(message, level: level, attributes: attributes,
+                                    logger: logger, configuration: configuration)
+      log_buffer.add(event)
+      nil
+    end
+
+    # Vero se i log sono attivi (master switch + flag): usato da LogDevice per NON valutare i block
+    # costosi (`logger.debug { dump }`) quando il logging è spento.
+    def logs_active?
+      logs_enabled?
+    end
+
+    # Forza l'invio dei log bufferizzati (chiamato anche allo shutdown del processo).
+    def flush_logs
+      @log_buffer&.flush
+      nil
+    end
 
     # Contatori diagnostici del client (accodati/scartati/spediti/falliti).
     #   CloseYourIt.stats.to_h # => { enqueued: …, dropped: …, sent: …, failed: … }
@@ -157,6 +198,33 @@ module CloseYourIt
       @client ||= Client.new(configuration)
     end
 
+    def log_buffer
+      @log_buffer ||= LogBuffer.new(client: client, configuration: configuration)
+    end
+
+    # I log seguono il master switch del client + il proprio flag dedicato.
+    def logs_enabled?
+      enabled? && configuration.logs_enabled
+    end
+
+    # Sampling indipendente dei log (1.0 = tutti, 0.0 = nessuno).
+    def logs_sampled?
+      rate = configuration.logs_sample_rate.to_f
+      return true if rate >= 1.0
+      return false if rate <= 0.0
+
+      Random.rand < rate
+    end
+
+    # Allo shutdown del processo svuota i log bufferizzati e ferma il timer (una sola registrazione).
+    # Senza, i log sotto-batch dei processi brevi (rake/CLI) andrebbero persi all'uscita.
+    def register_shutdown_flush
+      return if @shutdown_registered
+
+      @shutdown_registered = true
+      at_exit { @log_buffer&.shutdown }
+    end
+
     def ignored_exception?(exception)
       return true if exception.is_a?(CloseYourIt::Error)
 
@@ -187,7 +255,7 @@ module CloseYourIt
       exception.instance_variable_set(CAPTURED_FLAG, true)
     end
 
-    def default_logger
+    def default_internal_logger
       ::Logger.new($stdout).tap do |l|
         l.level = ::Logger::WARN
         l.progname = "CloseYourIt"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closeyourit-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Alessio Bussolari
@@ -41,14 +41,18 @@ files:
 - lib/closeyourit/configuration.rb
 - lib/closeyourit/event.rb
 - lib/closeyourit/events/error_event.rb
+- lib/closeyourit/events/log_event.rb
 - lib/closeyourit/events/message_event.rb
 - lib/closeyourit/events/slow_method_event.rb
 - lib/closeyourit/events/slow_query_event.rb
 - lib/closeyourit/instrumenter.rb
+- lib/closeyourit/log_buffer.rb
+- lib/closeyourit/log_device.rb
 - lib/closeyourit/monitor.rb
 - lib/closeyourit/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/query_source.rb
 - lib/closeyourit/rails/railtie.rb
 - lib/closeyourit/rails/request_context.rb