closeyourit-ruby 0.2.0

data/lib/closeyourit/sidekiq/error_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CloseYourIt
+  module Sidekiq
+    # Error handler Sidekiq (registrato dal railtie solo se Sidekiq è presente). Sidekiq invoca
+    # `call(exception, context, config)` e NON ri-solleva → qui catturiamo e basta.
+    class ErrorHandler
+      def call(exception, context, _config = nil)
+        apply_job_scope(context)
+        CloseYourIt.capture_exception(exception, handled: false)
+      ensure
+        CloseYourIt::Scope.reset!
+      end
+
+      private
+
+      def apply_job_scope(context)
+        job = (context && context[:job]) || {}
+        CloseYourIt.set_tag("job.class", job["class"]) if job["class"]
+        CloseYourIt.set_tag("job.queue", job["queue"]) if job["queue"]
+        CloseYourIt.set_context("sidekiq", { "jid" => job["jid"] }) if job["jid"]
+      end
+    end
+  end
+end

data/lib/closeyourit/subscribers/slow_query.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../events/slow_query_event"
+require_relative "../scrubber"
+
+module CloseYourIt
+  module Subscribers
+    # Riceve i dati di un evento `sql.active_record` e, se la query supera la soglia
+    # (escludendo SCHEMA/CACHE/TRANSACTION), invia un evento `slow_query`.
+    # Logica pura: il wiring ad ActiveSupport::Notifications vive nel Railtie.
+    class SlowQuery
+      IGNORED_NAMES = %w[SCHEMA CACHE TRANSACTION].freeze
+
+      def initialize(configuration = nil)
+        @configuration = configuration
+      end
+
+      def record(name:, duration_ms:, sql:, cached: false, connection: nil,
+                 binds: nil, type_casted_binds: nil, source: nil)
+        config = @configuration || CloseYourIt.configuration
+        return if ignored_name?(name)
+        return if duration_ms < config.slow_query_threshold_ms
+
+        event = SlowQueryEvent.new(
+          { name: name, sql: sql, cached: cached, connection: connection,
+            binds: binds, type_casted_binds: type_casted_binds, source: source },
+          duration_ms,
+          config
+        )
+        CloseYourIt.capture_event(event)
+      end
+
+      # Breadcrumb per OGNI query non di sistema (non solo lente): SQL offuscato, niente bind.
+      # Dà la cronologia "quali query prima del crash" allegata all'evento d'errore.
+      def breadcrumb(name:, sql:, duration_ms:, cached: false)
+        config = @configuration || CloseYourIt.configuration
+        return if ignored_name?(name)
+        return unless config.breadcrumbs_enabled
+
+        CloseYourIt.add_breadcrumb(
+          category: "query",
+          type: "query",
+          message: Scrubber.new(config).obfuscate_sql(sql),
+          data: { "name" => name, "duration_ms" => duration_ms.to_f.round(2), "cached" => cached }
+        )
+      end
+
+      private
+
+      def ignored_name?(name)
+        name.nil? || IGNORED_NAMES.include?(name)
+      end
+    end
+  end
+end

data/lib/closeyourit/transport.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module CloseYourIt
+  # Spedisce un payload a un path di ingest (errori → /events, metriche → /metrics) via HTTP POST
+  # con `Authorization: Bearer`. Mai solleva: ogni errore di rete è loggato e ingoiato.
+  class Transport
+    OPEN_TIMEOUT = 2
+    READ_TIMEOUT = 3
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def send_event(payload, path:)
+      post(payload, path)
+    rescue StandardError => e
+      CloseYourIt.logger.error("CloseYourIt transport: #{e.class}: #{e.message}")
+      nil
+    end
+
+    private
+
+    def post(payload, path)
+      uri = URI.parse("#{base_url}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = OPEN_TIMEOUT
+      http.read_timeout = READ_TIMEOUT
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request["Authorization"] = "Bearer #{@configuration.token}"
+      request["Content-Type"] = "application/json"
+      request["User-Agent"] = "closeyourit-ruby/#{VERSION}"
+      request.body = JSON.generate(payload)
+
+      http.request(request)
+    end
+
+    def base_url
+      @configuration.endpoint_url.to_s.chomp("/")
+    end
+  end
+end

data/lib/closeyourit/version.rb

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

data/lib/closeyourit-ruby.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "logger"
+
+require_relative "closeyourit/version"
+require_relative "closeyourit/configuration"
+require_relative "closeyourit/breadcrumb"
+require_relative "closeyourit/scope"
+require_relative "closeyourit/scrubber"
+require_relative "closeyourit/background_worker"
+require_relative "closeyourit/transport"
+require_relative "closeyourit/event"
+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/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/active_job_extension"
+require_relative "closeyourit/rails/error_subscriber"
+require_relative "closeyourit/sidekiq/error_handler"
+
+# CloseYourIt — client di telemetria (errori + statistiche di query/metodi lenti)
+# che invia gli eventi all'endpoint di ingest di CloseYourIt.
+#
+# Entry point della gemma (file con trattino come `sentry-ruby`):
+# `require "closeyourit-ruby"` carica il modulo `CloseYourIt`.
+module CloseYourIt
+  # Eccezione base interna: usata per evitare loop (le nostre eccezioni non vengono catturate).
+  class Error < StandardError; end
+
+  CAPTURED_FLAG = :@__closeyourit_captured
+
+  class << self
+    # Configura il client. Senza token/endpoint → no-op.
+    def init
+      @configuration = Configuration.new
+      @client = nil
+      yield(@configuration) if block_given?
+      @configuration.validate!
+      @configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configured?
+      !@configuration.nil?
+    end
+
+    def enabled?
+      configuration.enabled?
+    end
+
+    # Cattura un'eccezione e la spedisce (fire-and-forget). No-op se disabilitato,
+    # se l'eccezione è esclusa o già catturata.
+    def capture_exception(exception, handled: false, level: "error", contexts: nil)
+      return nil unless enabled?
+      return nil if ignored_exception?(exception)
+      return nil if exception_captured?(exception)
+
+      mark_captured(exception)
+      return nil unless sampled?
+
+      event = ErrorEvent.from_exception(
+        exception, configuration: configuration, handled: handled, level: level, contexts: contexts
+      )
+      client.capture_event(event)
+    end
+
+    # Spedisce un evento già costruito (slow_query/slow_method).
+    def capture_event(event)
+      return nil unless enabled?
+
+      client.capture_event(event)
+    end
+
+    # Invia un messaggio diagnostico esplicito (non un'eccezione). Soggetto a sampling + scope.
+    #   CloseYourIt.capture_message("cache miss storm", level: "warning")
+    def capture_message(message, level: "info")
+      return nil unless enabled?
+      return nil unless sampled?
+
+      event = MessageEvent.new(message, level: level, configuration: configuration)
+      client.capture_event(event)
+    end
+
+    # Cronometra un blocco e invia un slow_method se supera la soglia.
+    #   CloseYourIt.measure("checkout.total") { ... }
+    def measure(label, &block)
+      Instrumenter.measure(label, &block)
+    end
+
+    # --- Scope per-richiesta/job (user/tags/extra/contexts) ---
+    # Arricchiscono l'evento corrente; resettati a fine richiesta/job da middleware e estensioni.
+
+    def set_user(attributes)
+      Scope.current.set_user(attributes)
+    end
+
+    def set_tag(key, value)
+      Scope.current.set_tag(key, value)
+    end
+
+    def set_tags(attributes)
+      Scope.current.set_tags(attributes)
+    end
+
+    def set_context(key, attributes)
+      Scope.current.set_context(key, attributes)
+    end
+
+    def set_extra(key, value)
+      Scope.current.set_extra(key, value)
+    end
+
+    def configure_scope
+      yield(Scope.current) if block_given?
+    end
+
+    def clear_scope
+      Scope.reset!
+    end
+
+    # Aggiunge una briciola di contesto (query, navigazione, evento custom) all'evento corrente.
+    # No-op se breadcrumbs disabilitati; `data` viene scrubato (denylist) prima di essere salvato.
+    def add_breadcrumb(message: nil, category: nil, type: "default", level: "info", data: {})
+      return nil unless configuration.breadcrumbs_enabled
+
+      scrubbed = data.nil? || data.empty? ? data : Scrubber.new(configuration).filter_params(data)
+      Scope.current.add_breadcrumb(
+        Breadcrumb.new(message: message, category: category, type: type, level: level, data: scrubbed)
+      )
+    end
+
+    def logger
+      @logger ||= default_logger
+    end
+
+    attr_writer :logger
+
+    private
+
+    def client
+      @client ||= Client.new(configuration)
+    end
+
+    def ignored_exception?(exception)
+      return true if exception.is_a?(CloseYourIt::Error)
+
+      names = exception.class.ancestors.grep(Class).map(&:name).compact
+      configuration.excluded_exceptions.any? do |matcher|
+        if matcher.is_a?(Regexp)
+          names.any? { |name| matcher.match?(name) } || matcher.match?(exception.message.to_s)
+        else
+          names.include?(matcher)
+        end
+      end
+    end
+
+    # Sampling probabilistico: 1.0 invia sempre, 0.0 mai, intermedio via Random.rand.
+    def sampled?
+      rate = configuration.sample_rate.to_f
+      return true if rate >= 1.0
+      return false if rate <= 0.0
+
+      Random.rand < rate
+    end
+
+    def exception_captured?(exception)
+      exception.instance_variable_defined?(CAPTURED_FLAG)
+    end
+
+    def mark_captured(exception)
+      exception.instance_variable_set(CAPTURED_FLAG, true)
+    end
+
+    def default_logger
+      ::Logger.new($stdout).tap do |l|
+        l.level = ::Logger::WARN
+        l.progname = "CloseYourIt"
+      end
+    end
+  end
+end
+
+# Integrazione Rails automatica (solo se Rails è presente).
+require_relative "closeyourit/rails/railtie" if defined?(::Rails::Railtie)

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: closeyourit-ruby
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Alessio Bussolari
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Gemma client che cattura eccezioni e le statistiche di query e metodi
+  lenti e le invia, fire-and-forget, all'endpoint di ingest di CloseYourIt.
+email:
+- hello@bussolarialessio.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/closeyourit-ruby.rb
+- lib/closeyourit/background_worker.rb
+- lib/closeyourit/breadcrumb.rb
+- lib/closeyourit/breadcrumb_buffer.rb
+- lib/closeyourit/client.rb
+- lib/closeyourit/configuration.rb
+- lib/closeyourit/event.rb
+- lib/closeyourit/events/error_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/monitor.rb
+- lib/closeyourit/rails/active_job_extension.rb
+- lib/closeyourit/rails/capture_exceptions.rb
+- lib/closeyourit/rails/error_subscriber.rb
+- lib/closeyourit/rails/query_source.rb
+- lib/closeyourit/rails/railtie.rb
+- lib/closeyourit/rails/request_context.rb
+- lib/closeyourit/scope.rb
+- lib/closeyourit/scrubber.rb
+- lib/closeyourit/sidekiq/error_handler.rb
+- lib/closeyourit/subscribers/slow_query.rb
+- lib/closeyourit/transport.rb
+- lib/closeyourit/version.rb
+homepage: https://github.com/bussolabs/closeyourit-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bussolabs/closeyourit-ruby
+  source_code_uri: https://github.com/bussolabs/closeyourit-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Client di telemetria per CloseYourIt (errori + query/metodi lenti).
+test_files: []