closeyourit-ruby 0.2.0

data/lib/closeyourit/events/message_event.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module CloseYourIt
+  # Messaggio diagnostico esplicito (`CloseYourIt.capture_message`) nel formato evento Sentry
+  # (`message.formatted` + level). Fonde lo Scope corrente come ErrorEvent.
+  class MessageEvent < Event
+    def initialize(message, level:, configuration:)
+      super(configuration)
+      @message = message
+      @level = level
+    end
+
+    def to_h
+      base = compact(
+        "event_id" => SecureRandom.uuid.delete("-"),
+        "timestamp" => @occurred_at,
+        "platform" => "ruby",
+        "level" => @level,
+        "environment" => environment,
+        "release" => @configuration.release,
+        "server_name" => server_name,
+        "message" => { "formatted" => @message },
+        "contexts" => { "runtime" => { "name" => "ruby", "version" => RUBY_VERSION } },
+        "sdk" => sdk
+      )
+      deep_merge(base, CloseYourIt::Scope.current.to_event_hash)
+    end
+
+    def ingest_path(project_id)
+      "/api/v1/projects/#{project_id}/events"
+    end
+  end
+end

data/lib/closeyourit/events/slow_method_event.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../event"
+require_relative "../scrubber"
+
+module CloseYourIt
+  # Payload `kind=slow_method` per la pipeline metriche. Di default solo label + durata + posizione.
+  # Gli argomenti del metodo sono inviati SOLO se `capture_method_arguments` (opt-in, default OFF):
+  # posizionali per indice, kwargs per nome (scrub della chiave sensibile), valore via `inspect`
+  # troncato per sicurezza JSON. Vedi PDR §9.
+  class SlowMethodEvent < Event
+    def initialize(label, duration_ms, location, configuration, args: nil, kwargs: nil)
+      super(configuration)
+      @label = label
+      @duration_ms = duration_ms
+      @location = location
+      @args = args
+      @kwargs = kwargs
+      @scrubber = Scrubber.new(configuration)
+    end
+
+    def to_h
+      compact(
+        "kind" => "slow_method",
+        "sample_id" => SecureRandom.uuid,
+        "duration_ms" => @duration_ms.round(2),
+        "occurred_at" => @occurred_at,
+        "environment" => environment,
+        "label" => @label,
+        "file" => @location&.path,
+        "lineno" => @location&.lineno,
+        "arguments" => arguments,
+        "sdk" => sdk
+      )
+    end
+
+    def ingest_path(project_id)
+      "/api/v1/projects/#{project_id}/metrics"
+    end
+
+    private
+
+    # Argomenti — SOLO se capture_method_arguments (opt-in). Posizionali per indice; kwargs per nome con
+    # scrub della chiave sensibile (denylist password/token/…). Valore = inspect troncato (JSON-safe).
+    def arguments
+      return nil unless @configuration.capture_method_arguments
+
+      list = Array(@args).each_with_index.map { |arg, i| { "name" => "arg#{i + 1}", "value" => safe_value(arg) } }
+      (@kwargs || {}).each do |key, value|
+        list << { "name" => key.to_s, "value" => @scrubber.filter_value(key, safe_value(value)) }
+      end
+      list
+    end
+
+    def safe_value(value)
+      inspected = value.inspect.to_s
+      inspected.length > 120 ? "#{inspected[0, 117]}…" : inspected
+    end
+  end
+end

data/lib/closeyourit/events/slow_query_event.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../event"
+require_relative "../scrubber"
+
+module CloseYourIt
+  # Payload `kind=slow_query` per la pipeline metriche (`/api/v1/projects/:id/metrics`).
+  # Lo SQL è offuscato (binds esclusi) — vedi PDR §9.
+  class SlowQueryEvent < Event
+    def initialize(payload, duration_ms, configuration)
+      super(configuration)
+      @payload = payload
+      @duration_ms = duration_ms
+      @scrubber = Scrubber.new(configuration)
+    end
+
+    def to_h
+      compact(
+        "kind" => "slow_query",
+        "sample_id" => SecureRandom.uuid,
+        "duration_ms" => @duration_ms.round(2),
+        "occurred_at" => @occurred_at,
+        "environment" => environment,
+        "sql" => @scrubber.obfuscate_sql(@payload[:sql]),
+        "name" => @payload[:name],
+        "cached" => @payload.fetch(:cached, false),
+        "db_system" => db_system,
+        "source" => @payload[:source],
+        "bindings" => bindings,
+        "sdk" => sdk
+      )
+    end
+
+    def ingest_path(project_id)
+      "/api/v1/projects/#{project_id}/metrics"
+    end
+
+    private
+
+    def db_system
+      connection = @payload[:connection]
+      return nil unless connection.respond_to?(:adapter_name)
+
+      connection.adapter_name.to_s.downcase
+    end
+
+    # Valori dei bind — SOLO se capture_query_bindings (opt-in, default OFF). Scrub per nome colonna
+    # (denylist password/token/…); il valore è reso come stringa per sicurezza JSON.
+    def bindings
+      return nil unless @configuration.capture_query_bindings
+
+      binds = Array(@payload[:binds])
+      values = Array(@payload[:type_casted_binds])
+      binds.each_with_index.map do |attr, i|
+        name = attr.respond_to?(:name) ? attr.name.to_s : attr.to_s
+        { "name" => name, "value" => @scrubber.filter_value(name, values[i]).to_s }
+      end
+    end
+  end
+end

data/lib/closeyourit/instrumenter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "events/slow_method_event"
+
+module CloseYourIt
+  # Cronometra blocchi/metodi con `CLOCK_MONOTONIC` e invia un `slow_method` se la durata supera la
+  # soglia. Gli argomenti sono inviati solo se `capture_method_arguments` (opt-in) — vedi SlowMethodEvent.
+  module Instrumenter
+    module_function
+
+    def measure(label, args: nil, kwargs: nil)
+      location = caller_locations(1, 1)&.first
+      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)
+    end
+
+    def report(label, duration_ms, location = nil, args: nil, kwargs: nil)
+      config = CloseYourIt.configuration
+      return if duration_ms < config.slow_method_threshold_ms
+
+      CloseYourIt.capture_event(
+        SlowMethodEvent.new(label, duration_ms, location, config, args: args, kwargs: kwargs)
+      )
+    end
+  end
+end

data/lib/closeyourit/monitor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "instrumenter"
+
+module CloseYourIt
+  # Macro per strumentare automaticamente un metodo:
+  #
+  #   class Report
+  #     include CloseYourIt::Monitor
+  #     def generate(...) = ...
+  #     monitor :generate
+  #   end
+  #
+  # Wrappa il metodo via `Module#prepend` cronometrandolo, senza cambiarne firma/risultato.
+  module Monitor
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def monitor(method_name, label: nil)
+        wrapper = Module.new do
+          define_method(method_name) do |*args, **kwargs, &block|
+            measured_label = label || "#{self.class}##{method_name}"
+            CloseYourIt::Instrumenter.measure(measured_label, args: args, kwargs: kwargs) do
+              super(*args, **kwargs, &block)
+            end
+          end
+        end
+        prepend(wrapper)
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/active_job_extension.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+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
+    # testabile senza ActiveSupport/ActiveJob.
+    module ActiveJobExtension
+      def self.included(base)
+        base.around_perform do |job, block|
+          CloseYourIt::Rails::ActiveJobExtension.monitor(job) { block.call }
+        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).
+      def self.monitor(job)
+        return yield unless CloseYourIt.configuration.report_active_job_errors
+
+        begin
+          apply_job_scope(job)
+          yield
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          CloseYourIt.capture_exception(e, handled: false)
+          raise
+        ensure
+          CloseYourIt::Scope.reset!
+        end
+      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)
+
+        context = {}
+        context["job_id"] = job.job_id if job.respond_to?(:job_id)
+        context["executions"] = job.executions if job.respond_to?(:executions)
+        CloseYourIt.set_context("active_job", context) unless context.empty?
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/capture_exceptions.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module Rails
+    # Rack middleware: cattura le eccezioni non gestite, le invia a CloseYourIt
+    # e le **ri-solleva** (l'app continua a gestirle come prima). Rack puro, nessuna
+    # dipendenza da Rails → testabile in isolamento.
+    class CaptureExceptions
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        CloseYourIt.capture_exception(e)
+        raise
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/error_subscriber.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module Rails
+    # Sottoscrittore di `ActiveSupport::ErrorReporter` (Rails 7+): cattura gli errori HANDLED
+    # riportati via `Rails.error.report`/`Rails.error.handle`. Gli unhandled passano già dal
+    # middleware Rack → la dedup (ivar sull'istanza) evita il doppio invio.
+    class ErrorSubscriber
+      SEVERITY_TO_LEVEL = { error: "error", warning: "warning", info: "info" }.freeze
+
+      # Sorgenti interne rumorose da non inoltrare (evita loop/duplicati).
+      IGNORED_SOURCES = %w[closeyourit].freeze
+
+      def report(error, handled:, severity:, context:, source: nil)
+        return if source && IGNORED_SOURCES.include?(source)
+        return unless CloseYourIt.configuration.capture_handled_errors
+
+        level = SEVERITY_TO_LEVEL.fetch(severity, "error")
+        contexts = context && !context.empty? ? { "rails_error" => stringify(context) } : nil
+        CloseYourIt.capture_exception(error, handled: handled, level: level, contexts: contexts)
+      end
+
+      private
+
+      def stringify(context)
+        context.each_with_object({}) { |(key, value), acc| acc[key.to_s] = value }
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/query_source.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module Rails
+    # Call-site applicativo di una query lenta (privacy-safe → sempre inviato): primo frame della
+    # backtrace ripulito da Rails.backtrace_cleaner (rimuove gem/framework, tiene il codice app),
+    # senza il suffisso ":in '...'". Es. "app/models/order.rb:42".
+    module QuerySource
+      def self.from_caller(backtrace = caller)
+        frame = ::Rails.backtrace_cleaner.clean(backtrace).first
+        return nil if frame.nil?
+
+        frame.split(":in ", 2).first
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/railtie.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "capture_exceptions"
+require_relative "request_context"
+require_relative "active_job_extension"
+require_relative "error_subscriber"
+require_relative "../sidekiq/error_handler"
+require_relative "query_source"
+require_relative "../subscribers/slow_query"
+
+module CloseYourIt
+  module Rails
+    # Aggancia il client a Rails: Rack middleware di cattura eccezioni +
+    # subscriber `sql.active_record` per le query lente.
+    class Railtie < ::Rails::Railtie
+      initializer "closeyourit.use_rack_middleware" do |app|
+        app.config.middleware.use CloseYourIt::Rails::CaptureExceptions
+        # RequestContext deve AVVOLGERE CaptureExceptions: lo scope dev'essere già popolato
+        # quando l'eccezione risale a CaptureExceptions.
+        app.config.middleware.insert_before(
+          CloseYourIt::Rails::CaptureExceptions,
+          CloseYourIt::Rails::RequestContext
+        )
+      end
+
+      initializer "closeyourit.subscribe_slow_queries" do
+        subscriber = CloseYourIt::Subscribers::SlowQuery.new
+
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          subscriber.record(
+            name: event.payload[:name],
+            duration_ms: event.duration,
+            sql: event.payload[:sql],
+            cached: event.payload.fetch(:cached, false),
+            connection: event.payload[:connection],
+            binds: event.payload[:binds],
+            type_casted_binds: event.payload[:type_casted_binds],
+            source: CloseYourIt::Rails::QuerySource.from_caller
+          )
+          subscriber.breadcrumb(
+            name: event.payload[:name],
+            sql: event.payload[:sql],
+            duration_ms: event.duration,
+            cached: event.payload.fetch(:cached, false)
+          )
+        end
+      end
+
+      # Cattura gli errori di ActiveJob/Solid Queue (around_perform).
+      initializer "closeyourit.active_job" do
+        ActiveSupport.on_load(:active_job) do
+          include CloseYourIt::Rails::ActiveJobExtension
+        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)
+          ::Rails.error.subscribe(CloseYourIt::Rails::ErrorSubscriber.new)
+        end
+      end
+
+      # Cattura gli errori dei job Sidekiq (solo se Sidekiq è presente).
+      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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/closeyourit/rails/request_context.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module Rails
+    # Rack middleware: popola lo Scope con il contesto HTTP della richiesta (method/url/header)
+    # così l'evento d'errore catturato a valle sa "in quale pagina" è capitato. Deve avvolgere
+    # `CaptureExceptions` (insert_before) per essere già popolato quando l'eccezione risale.
+    # Rack puro (legge `env`, nessuna dipendenza da Rails) → testabile in isolamento.
+    class RequestContext
+      # Header con prefisso non-HTTP_ in env Rack.
+      RAW_HEADERS = %w[CONTENT_TYPE CONTENT_LENGTH].freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        CloseYourIt::Scope.current.request = build_request(env) if active?
+        @app.call(env)
+      ensure
+        CloseYourIt::Scope.reset!
+      end
+
+      private
+
+      def active?
+        CloseYourIt.enabled? && CloseYourIt.configuration.capture_request
+      rescue StandardError
+        false
+      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)
+        request = {
+          "method"  => env["REQUEST_METHOD"],
+          "url"     => build_url(env),
+          "headers" => allowed_headers(env)
+        }.reject { |_key, value| value.nil? }
+
+        if CloseYourIt.configuration.send_pii
+          query = env["QUERY_STRING"]
+          request["query_string"] = query if query && !query.empty?
+          ip = env["REMOTE_ADDR"]
+          request["env"] = { "REMOTE_ADDR" => ip } if ip
+        end
+
+        request
+      rescue StandardError
+        # La telemetria non deve mai disturbare la richiesta ospite.
+        nil
+      end
+
+      def build_url(env)
+        scheme = env["rack.url_scheme"] || "http"
+        host = env["HTTP_HOST"] || env["SERVER_NAME"]
+        return nil if host.nil?
+
+        "#{scheme}://#{host}#{env["PATH_INFO"]}"
+      end
+
+      def allowed_headers(env)
+        CloseYourIt.configuration.request_header_allowlist.each_with_object({}) do |name, acc|
+          value = env[header_env_key(name)]
+          acc[name] = value if value
+        end
+      end
+
+      def header_env_key(name)
+        upcased = name.upcase.tr("-", "_")
+        RAW_HEADERS.include?(upcased) ? upcased : "HTTP_#{upcased}"
+      end
+    end
+  end
+end

data/lib/closeyourit/scope.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "breadcrumb_buffer"
+
+module CloseYourIt
+  # Contesto per-richiesta (o per-job) isolato per execution-context (Fiber storage):
+  # user/tags/extra/contexts/request. Letto da ErrorEvent#to_h sul thread chiamante (sincrono)
+  # → il worker di invio non lo vede mai e lo scope non cola tra richieste.
+  class Scope
+    STORAGE_KEY = :__closeyourit_scope
+
+    class << self
+      # Scope dell'execution-context corrente. Usa `ActiveSupport::IsolatedExecutionState` quando
+      # presente (rispetta isolation_level: thread su Puma, fiber su Falcon), altrimenti
+      # `Thread.current` (thread-local puro, NON ereditato dai thread figli → niente bleed).
+      def current
+        store[STORAGE_KEY] ||= new
+      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!
+        store[STORAGE_KEY] = nil
+      end
+
+      private
+
+      def store
+        if defined?(::ActiveSupport::IsolatedExecutionState)
+          ::ActiveSupport::IsolatedExecutionState
+        else
+          ::Thread.current
+        end
+      end
+    end
+
+    attr_accessor :request
+    attr_reader :user, :tags, :extra, :contexts, :breadcrumbs
+
+    def initialize
+      clear
+    end
+
+    def set_user(attributes)
+      @user.merge!(stringify_keys(attributes))
+    end
+
+    def set_tag(key, value)
+      @tags[key.to_s] = value
+    end
+
+    def set_tags(attributes)
+      attributes.each { |key, value| set_tag(key, value) }
+    end
+
+    def set_context(key, attributes)
+      @contexts[key.to_s] = stringify_keys(attributes)
+    end
+
+    def set_extra(key, value)
+      @extra[key.to_s] = value
+    end
+
+    def add_breadcrumb(breadcrumb)
+      @breadcrumbs.add(breadcrumb)
+    end
+
+    def clear
+      @user        = {}
+      @tags        = {}
+      @extra       = {}
+      @contexts    = {}
+      @request     = 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.
+    def to_event_hash
+      {
+        "user"        => serialize_user,
+        "tags"        => presence(@tags),
+        "extra"       => presence(@extra),
+        "contexts"    => presence(@contexts),
+        "request"     => @request,
+        "breadcrumbs" => breadcrumbs_payload
+      }.reject { |_key, value| value.nil? }
+    end
+
+    private
+
+    # `user.id` sempre; email/ip_address/username solo con `send_pii` (il backend li strippa
+    # comunque — difesa in profondità).
+    def serialize_user
+      return nil if @user.empty?
+      return @user if CloseYourIt.configuration.send_pii
+
+      presence(@user.slice("id"))
+    end
+
+    def breadcrumbs_payload
+      return nil if @breadcrumbs.empty?
+
+      { "values" => @breadcrumbs.to_a }
+    end
+
+    def presence(hash)
+      hash.empty? ? nil : hash
+    end
+
+    def stringify_keys(attributes)
+      attributes.each_with_object({}) { |(key, value), acc| acc[key.to_s] = value }
+    end
+  end
+end

data/lib/closeyourit/scrubber.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  # Rimozione PII dai payload: filtro chiavi sensibili, normalizzazione SQL, scrub messaggi.
+  # Privacy-by-default — vedi PDR §9.
+  class Scrubber
+    FILTERED = "[FILTERED]"
+
+    # Token di chiavi sempre redatti (match per sottostringa, normalizzato).
+    DENYLIST = %w[
+      password passwd secret token api_key apikey authorization
+      cookie set-cookie csrf credit_card card cvv ssn iban
+    ].freeze
+
+    STRING_LITERAL = /'(?:[^']|'')*'/
+    NUMERIC_LITERAL = /\b\d+(?:\.\d+)?\b/
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    # Filtra ricorsivamente Hash/Array sostituendo i valori delle chiavi sensibili.
+    def filter_params(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, val), acc|
+          acc[key] = sensitive_key?(key) ? FILTERED : filter_params(val)
+        end
+      when Array
+        value.map { |item| filter_params(item) }
+      else
+        value
+      end
+    end
+
+    # Maschera i literal (stringa/numerici) nello SQL, preservando la struttura.
+    def obfuscate_sql(sql)
+      return sql if sql.nil? || !@configuration.obfuscate_sql
+
+      sql.to_s.gsub(STRING_LITERAL, "?").gsub(NUMERIC_LITERAL, "?")
+    end
+
+    def scrub_message(message)
+      return message if message.nil?
+
+      @configuration.scrub_message_patterns.reduce(message.to_s) do |acc, pattern|
+        acc.gsub(pattern, FILTERED)
+      end
+    end
+
+    # Valore di un singolo bind/argomento: redatto se il nome (colonna/parametro) è sensibile.
+    def filter_value(key, value)
+      sensitive_key?(key) ? FILTERED : value
+    end
+
+    private
+
+    def sensitive_key?(key)
+      normalized = normalize(key)
+      return true if DENYLIST.any? { |token| normalized.include?(normalize(token)) }
+
+      @configuration.filter_parameters.any? do |param|
+        param.is_a?(Regexp) ? param.match?(key.to_s) : normalized.include?(normalize(param))
+      end
+    end
+
+    def normalize(value)
+      value.to_s.downcase.gsub(/[^a-z0-9]/, "")
+    end
+  end
+end