otel_beacon 0.1.0

data/lib/otel_beacon/context.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module Context
+    class << self
+      def current
+        Thread.current[:otel_beacon_context] ||= default_context
+      end
+
+      def reset!
+        Thread.current[:otel_beacon_context] = default_context
+      end
+
+      def user
+        current[:user]
+      end
+
+      def tags
+        current[:tags]
+      end
+
+      def extra
+        current[:extra]
+      end
+
+      def breadcrumbs
+        current[:breadcrumbs]
+      end
+
+      def contexts
+        current[:contexts]
+      end
+
+      def fingerprint
+        current[:fingerprint]
+      end
+
+      def fingerprint=(value)
+        current[:fingerprint] = value
+      end
+
+      def push_scope
+        stack << deep_dup(current)
+      end
+
+      def pop_scope
+        if stack.any?
+          Thread.current[:otel_beacon_context] = stack.pop
+        else
+          reset!
+        end
+      end
+
+      def stack
+        Thread.current[:otel_beacon_scope_stack] ||= []
+      end
+
+      private
+
+      def default_context
+        { user: {}, tags: {}, extra: {}, breadcrumbs: [], contexts: {}, fingerprint: nil }
+      end
+
+      def deep_dup(hash)
+        hash.transform_values do |v|
+          case v
+          when Hash then v.dup
+          when Array then v.dup
+          else v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/otel_beacon/integrations/sidekiq.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module Integrations
+    class SidekiqMiddleware
+      def call(worker, job, queue)
+        OtelBeacon.reset_context!
+        OtelBeacon.set_tags(
+          job_class: worker.class.name,
+          queue: queue,
+          job_id: job["jid"]
+        )
+        OtelBeacon.set_context(:sidekiq,
+                               queue: queue,
+                               retry_count: job["retry_count"] || 0,
+                               created_at: job["created_at"],
+                               enqueued_at: job["enqueued_at"])
+        OtelBeacon.add_breadcrumb(:job, "#{worker.class.name} started", queue: queue, jid: job["jid"])
+
+        yield
+      rescue StandardError => e
+        OtelBeacon.capture_exception(e, extra: {
+                                       job_class: worker.class.name,
+                                       job_id: job["jid"],
+                                       queue: queue,
+                                       args: filtered_args(job["args"])
+                                     })
+        raise
+      ensure
+        OtelBeacon.flush_context_to_span
+      end
+
+      private
+
+      def filtered_args(args)
+        return [] unless args.is_a?(Array)
+
+        args.first(5).map do |arg|
+          case arg
+          when Hash then OtelBeacon::Sanitizer.sanitize_params(arg)
+          when String then arg.length > 100 ? "#{arg[0..100]}..." : arg
+          else arg.inspect[0..100]
+          end
+        end
+      rescue StandardError
+        [ "[unable to serialize]" ]
+      end
+    end
+
+    module Sidekiq
+      def self.setup
+        return unless defined?(::Sidekiq)
+
+        ::Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add OtelBeacon::Integrations::SidekiqMiddleware
+          end
+        end
+      end
+    end
+  end
+end

data/lib/otel_beacon/log_subscriber.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def capture_exception(event)
+      error do
+        exception = event.payload[:exception]
+        "Captured exception: #{exception.class} - #{exception.message}"
+      end
+    end
+
+    def capture_message(event)
+      info do
+        "Captured message: #{event.payload[:message]} (level: #{event.payload[:level]})"
+      end
+    end
+
+    def add_breadcrumb(event)
+      debug do
+        "Added breadcrumb: #{event.payload[:category]} - #{event.payload[:message]}"
+      end
+    end
+
+    def context_error(event)
+      error do
+        "Context error: #{event.payload[:error]}"
+      end
+    end
+  end
+end

data/lib/otel_beacon/rails/controller_methods.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module Rails
+    module ControllerMethods
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :otel_beacon_setup_context
+        around_action :otel_beacon_capture_breadcrumbs
+        rescue_from StandardError, with: :otel_beacon_capture_and_reraise
+      end
+
+      private
+
+      def otel_beacon_setup_context
+        OtelBeacon.reset_context!
+
+        user = OtelBeacon.config.resolve_current_user(self)
+        if user
+          attrs = OtelBeacon.config.extract_user_attributes(user)
+          OtelBeacon.set_user(**attrs) if attrs.any?
+        end
+
+        OtelBeacon.set_tags(
+          controller: controller_name,
+          action: action_name,
+          environment: ::Rails.env.to_s
+        )
+
+        OtelBeacon::RuntimeContext.set_device_context(request)
+        OtelBeacon::RuntimeContext.set_browser_context(request)
+      end
+
+      def otel_beacon_capture_breadcrumbs
+        OtelBeacon.add_breadcrumb(:controller, "#{controller_name}##{action_name}", params: otel_beacon_filtered_params)
+        yield
+      ensure
+        OtelBeacon.flush_context_to_span
+      end
+
+      def otel_beacon_capture_and_reraise(exception)
+        OtelBeacon.capture_exception(
+          exception,
+          request: request,
+          params: params,
+          extra: { controller: controller_name, action: action_name, format: request.format.to_s }
+        )
+        raise exception
+      end
+
+      def otel_beacon_filtered_params
+        params.to_unsafe_h.except(:controller, :action, :format)
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/lib/otel_beacon/rails/job_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module Rails
+    module JobMethods
+      extend ActiveSupport::Concern
+
+      included do
+        around_perform :otel_beacon_capture_job
+      end
+
+      private
+
+      def otel_beacon_capture_job
+        OtelBeacon.reset_context!
+        OtelBeacon.set_tags(
+          job_class: self.class.name,
+          queue: queue_name || "default",
+          job_id: job_id
+        )
+        OtelBeacon.add_breadcrumb(:job, "#{self.class.name} started", queue: queue_name, job_id: job_id)
+
+        yield
+      rescue StandardError => e
+        OtelBeacon.capture_exception(e, extra: {
+                                       job_class: self.class.name,
+                                       job_id: job_id,
+                                       queue: queue_name,
+                                       arguments: filtered_arguments
+                                     })
+        raise
+      ensure
+        OtelBeacon.flush_context_to_span
+      end
+
+      def filtered_arguments
+        arguments.first(5).map do |arg|
+          case arg
+          when Hash then OtelBeacon::Sanitizer.sanitize_params(arg)
+          when String then arg.length > 100 ? "#{arg[0..100]}..." : arg
+          else arg.inspect[0..100]
+          end
+        end
+      rescue StandardError
+        [ "[unable to serialize]" ]
+      end
+    end
+  end
+end

data/lib/otel_beacon/rails/logger.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "logger"
+require "delegate"
+
+module OtelBeacon
+  module Rails
+    class Logger < SimpleDelegator
+      SEVERITY_MAP = {
+        ::Logger::DEBUG => "DEBUG",
+        ::Logger::INFO => "INFO",
+        ::Logger::WARN => "WARN",
+        ::Logger::ERROR => "ERROR",
+        ::Logger::FATAL => "FATAL",
+        ::Logger::UNKNOWN => "UNKNOWN"
+      }.freeze
+
+      def initialize(original_logger)
+        super(original_logger)
+        @original_logger = original_logger
+        @otel_logger = nil
+      end
+
+      def add(severity, message = nil, progname = nil)
+        message = yield if block_given?
+        message ||= progname
+        result = @original_logger.add(severity, message, progname)
+        emit_to_otel(severity, message) if message
+        result
+      end
+
+      def level
+        @original_logger.level
+      end
+
+      def level=(value)
+        @original_logger.level = value
+      end
+
+      def debug(message = nil)
+        message = yield if block_given?
+        @original_logger.debug(message)
+        emit_to_otel(::Logger::DEBUG, message) if message
+      end
+
+      def info(message = nil)
+        message = yield if block_given?
+        @original_logger.info(message)
+        emit_to_otel(::Logger::INFO, message) if message
+      end
+
+      def warn(message = nil)
+        message = yield if block_given?
+        @original_logger.warn(message)
+        emit_to_otel(::Logger::WARN, message) if message
+      end
+
+      def error(message = nil)
+        message = yield if block_given?
+        @original_logger.error(message)
+        emit_to_otel(::Logger::ERROR, message) if message
+      end
+
+      def fatal(message = nil)
+        message = yield if block_given?
+        @original_logger.fatal(message)
+        emit_to_otel(::Logger::FATAL, message) if message
+      end
+
+      private
+
+      def emit_to_otel(severity, message)
+        return unless otel_configured?
+
+        attributes = {
+          "log.source" => "rails",
+          "service.name" => OtelBeacon.config.service_name
+        }
+
+        current_span = OpenTelemetry::Trace.current_span
+        if current_span.context.valid?
+          attributes["trace_id"] = current_span.context.hex_trace_id
+          attributes["span_id"] = current_span.context.hex_span_id
+        end
+
+        otel_logger.on_emit(
+          severity_text: SEVERITY_MAP[severity] || "INFO",
+          severity_number: severity_to_number(severity),
+          body: message.to_s,
+          attributes: attributes,
+          context: OpenTelemetry::Context.current
+        )
+      rescue StandardError => e
+        @original_logger&.debug("OtelBeacon log emit failed: #{e.message}")
+      end
+
+      def otel_configured?
+        OpenTelemetry.logger_provider&.respond_to?(:logger)
+      end
+
+      def otel_logger
+        @otel_logger ||= OpenTelemetry.logger_provider.logger(
+          name: OtelBeacon.config.service_name,
+          version: OtelBeacon::VERSION
+        )
+      end
+
+      def severity_to_number(severity)
+        case severity
+        when ::Logger::DEBUG then 5
+        when ::Logger::INFO then 9
+        when ::Logger::WARN then 13
+        when ::Logger::ERROR then 17
+        when ::Logger::FATAL then 21
+        else 0
+        end
+      end
+    end
+  end
+end

data/lib/otel_beacon/rails/mailer_methods.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module Rails
+    module MailerMethods
+      extend ActiveSupport::Concern
+
+      included do
+        around_action :otel_beacon_capture_mailer
+        rescue_from StandardError, with: :otel_beacon_mailer_exception
+      end
+
+      private
+
+      def otel_beacon_capture_mailer
+        OtelBeacon.reset_context!
+        OtelBeacon.set_tags(
+          mailer_class: self.class.name,
+          mailer_action: action_name
+        )
+        OtelBeacon.add_breadcrumb(:mailer, "#{self.class.name}##{action_name}")
+
+        yield
+      ensure
+        OtelBeacon.flush_context_to_span
+      end
+
+      def otel_beacon_mailer_exception(exception)
+        OtelBeacon.capture_exception(exception, extra: {
+                                       mailer_class: self.class.name,
+                                       mailer_action: action_name
+                                     })
+        raise exception
+      end
+    end
+  end
+end

data/lib/otel_beacon/rails/railtie.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.otel_beacon = ActiveSupport::OrderedOptions.new
+
+      initializer "otel_beacon.config", before: :run_prepare_callbacks do |app|
+        app.config.otel_beacon.each do |key, value|
+          OtelBeacon.public_send("#{key}=", value)
+        end
+      end
+
+      initializer "otel_beacon.app_executor", before: :run_prepare_callbacks do |_app|
+        OtelBeacon.on_thread_error = ->(exception) { ::Rails.error.report(exception, handled: false) }
+      end
+
+      initializer "otel_beacon.logger", before: :run_prepare_callbacks do
+        ActiveSupport.on_load(:otel_beacon) do
+          self.logger = ::Rails.logger
+        end
+
+        OtelBeacon::LogSubscriber.attach_to :otel_beacon
+      end
+
+      initializer "otel_beacon.environment", before: :run_prepare_callbacks do
+        OtelBeacon.environment = ::Rails.env.to_s
+      end
+
+      initializer "otel_beacon.integrations", after: :load_config_initializers do
+        OtelBeacon.set_runtime_context
+
+        ActiveSupport.on_load(:action_controller) do
+          include OtelBeacon::Rails::ControllerMethods
+        end
+
+        ActiveSupport.on_load(:active_job) do
+          include OtelBeacon::Rails::JobMethods
+        end
+
+        ActiveSupport.on_load(:action_mailer) do
+          include OtelBeacon::Rails::MailerMethods
+        end
+
+        if defined?(::Sidekiq)
+          require_relative "../integrations/sidekiq"
+          OtelBeacon::Integrations::Sidekiq.setup
+        end
+      end
+    end
+  end
+end

data/lib/otel_beacon/runtime_context.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module RuntimeContext
+    class << self
+      def set_defaults
+        set_runtime_context
+        set_os_context
+        set_app_context
+      end
+
+      def set_runtime_context
+        OtelBeacon.set_context(:runtime,
+                               name: "ruby",
+                               version: RUBY_VERSION,
+                               platform: RUBY_PLATFORM,
+                               engine: RUBY_ENGINE,
+                               engine_version: RUBY_ENGINE_VERSION)
+      end
+
+      def set_os_context
+        OtelBeacon.set_context(:os,
+                               name: os_name,
+                               version: os_version,
+                               kernel_version: `uname -r`.strip)
+      rescue StandardError
+        OtelBeacon.set_context(:os, name: RUBY_PLATFORM)
+      end
+
+      def set_app_context
+        ctx = {
+          name: OtelBeacon.config.service_name,
+          version: OtelBeacon.config.service_version,
+          environment: OtelBeacon.config.environment.to_s
+        }
+        ctx[:rails_version] = ::Rails.version if defined?(::Rails)
+        OtelBeacon.set_context(:app, **ctx)
+      end
+
+      def set_device_context(request)
+        return unless request
+
+        OtelBeacon.set_context(:device,
+                               user_agent: request.user_agent,
+                               ip_address: request.remote_ip)
+      rescue StandardError
+      end
+
+      def set_browser_context(request)
+        return unless request
+
+        ua = request.user_agent.to_s
+        OtelBeacon.set_context(:browser,
+                               user_agent: ua,
+                               name: parse_browser_name(ua),
+                               version: parse_browser_version(ua))
+      rescue StandardError
+      end
+
+      private
+
+      def os_name
+        case RUBY_PLATFORM
+        when /darwin/ then "macOS"
+        when /linux/ then "Linux"
+        when /win|mingw/ then "Windows"
+        when /freebsd/ then "FreeBSD"
+        else RUBY_PLATFORM
+        end
+      end
+
+      def os_version
+        case RUBY_PLATFORM
+        when /darwin/
+          `sw_vers -productVersion`.strip
+        when /linux/
+          File.read("/etc/os-release").match(/VERSION_ID="?([^"\n]+)"?/)&.[](1) || "unknown"
+        else
+          "unknown"
+        end
+      rescue StandardError
+        "unknown"
+      end
+
+      def parse_browser_name(ua)
+        case ua
+        when /Chrome/i then "Chrome"
+        when /Firefox/i then "Firefox"
+        when /Safari/i then "Safari"
+        when /Edge/i then "Edge"
+        when /MSIE|Trident/i then "Internet Explorer"
+        else "Unknown"
+        end
+      end
+
+      def parse_browser_version(ua)
+        match = ua.match(%r{(?:Chrome|Firefox|Safari|Edge|MSIE|rv:)[/ ]?([\d.]+)}i)
+        match ? match[1] : "unknown"
+      end
+    end
+  end
+end

data/lib/otel_beacon/sanitizer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  module Sanitizer
+    class << self
+      def sanitize_params(params, depth = 0)
+        return {} if params.nil?
+        return "[TRUNCATED]" if depth > 5
+
+        case params
+        when Hash
+          params.each_with_object({}) do |(k, v), h|
+            h[k] = sensitive_field?(k) ? "[FILTERED]" : sanitize_params(v, depth + 1)
+          end
+        when Array
+          params.first(100).map { |v| sanitize_params(v, depth + 1) }
+        when String
+          params.length > 1000 ? "#{params[0..1000]}...[TRUNCATED]" : params
+        else
+          params
+        end
+      end
+
+      def extract_params(params)
+        raw = begin
+          params.to_unsafe_h
+        rescue StandardError
+          begin
+            params.to_h
+          rescue StandardError
+            {}
+          end
+        end
+        sanitize_params(raw)
+      end
+
+      def truncate_string(string, max_length: 500)
+        return string if string.length <= max_length
+
+        "#{string[0...max_length]}..."
+      end
+
+      private
+
+      def sensitive_field?(key)
+        key.to_s.downcase.match?(OtelBeacon.config.sanitize_pattern)
+      end
+    end
+  end
+end

data/lib/otel_beacon/scope.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OtelBeacon
+  class Scope
+    def set_user(id: nil, email: nil, username: nil, ip_address: nil, **extra)
+      Context.current[:user] = { id: id, email: email, username: username, ip_address: ip_address }.compact.merge(extra)
+    end
+
+    def set_tags(**tags)
+      Context.tags.merge!(tags.transform_values(&:to_s))
+    end
+
+    def set_tag(key, value)
+      Context.tags[key.to_sym] = value.to_s
+    end
+
+    def set_extra(**extra)
+      Context.extra.merge!(extra)
+    end
+
+    def set_context(name, **data)
+      Context.contexts[name.to_sym] = data
+    end
+
+    def set_fingerprint(*fingerprint)
+      Context.fingerprint = fingerprint.flatten
+    end
+
+    def add_breadcrumb(category, message, level: :info, **data)
+      Client.add_breadcrumb(category, message, level: level, **data)
+    end
+
+    def clear
+      Context.reset!
+    end
+  end
+end

data/lib/otel_beacon/version.rb

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