lapsoss 0.1.0

data/lib/lapsoss/adapters/appsignal_adapter.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require_relative "../http_client"
+
+module Lapsoss
+  module Adapters
+    class AppsignalAdapter < Base
+      PUSH_API_URI = "https://push.appsignal.com"
+      ERRORS_API_URI = "https://appsignal-endpoint.net"
+      JSON_CONTENT_TYPE = "application/json; charset=UTF-8"
+
+      def initialize(name, settings = {})
+        super(name, settings)
+        @push_api_key = settings[:push_api_key] || ENV["APPSIGNAL_PUSH_API_KEY"]
+        @frontend_api_key = settings[:frontend_api_key] || ENV["APPSIGNAL_FRONTEND_API_KEY"]
+        @app_name = settings[:app_name] || ENV["APPSIGNAL_APP_NAME"]
+        @environment = Lapsoss.configuration.environment
+
+        validate_settings!
+
+        @push_client = create_http_client(PUSH_API_URI) if @push_api_key
+        @errors_client = create_http_client(ERRORS_API_URI) if @frontend_api_key
+      end
+
+      def capture(event)
+        return unless enabled? && @errors_client
+
+        payload = build_error_payload(event)
+        return unless payload
+
+        path = "/errors?api_key=#{@frontend_api_key}"
+        headers = { "Content-Type" => JSON_CONTENT_TYPE }
+
+        begin
+          @errors_client.post(path, body: JSON.generate(payload), headers: headers)
+        rescue DeliveryError => e
+          # Log the error and potentially notify error handler
+          Lapsoss.configuration.logger&.error("[Lapsoss::AppsignalAdapter] Failed to deliver event: #{e.message}")
+          Lapsoss.configuration.error_handler&.call(e)
+
+          # Re-raise to let the caller know delivery failed
+          raise
+        end
+      end
+
+      def shutdown
+        @push_client&.shutdown
+        @errors_client&.shutdown
+        super
+      end
+
+      private
+
+      def build_error_payload(event)
+        case event.type
+        when :exception
+          build_exception_payload(event)
+        when :message
+          build_message_payload(event)
+        end
+      end
+
+      def build_exception_payload(event)
+        {
+          timestamp: event.timestamp.to_i,
+          namespace: event.context[:namespace] || "backend",
+          error: {
+            name: event.exception.class.name,
+            message: event.exception.message,
+            backtrace: event.exception.backtrace || []
+          },
+          tags: stringify_hash(event.context[:tags]),
+          params: stringify_hash(event.context[:params]),
+          environment: build_environment_context(event),
+          breadcrumbs: event.context[:breadcrumbs]
+        }
+      end
+
+      def build_message_payload(event)
+        # AppSignal's Error API expects exception-like structure
+        # Instead of creating fake exceptions, we'll structure the message properly
+        # but clearly indicate it's a log message, not an exception
+
+        unless [:error, :fatal, :critical].include?(event.level)
+          # Log when messages are dropped due to level filtering
+          Lapsoss.configuration.logger&.debug(
+            "[Lapsoss::AppsignalAdapter] Dropping message with level '#{event.level}' - " \
+            "AppSignal only supports :error, :fatal, and :critical levels for messages"
+          )
+          return nil
+        end
+
+        {
+          action: event.context[:action] || "log_message",
+          path: event.context[:path] || "/",
+          exception: {
+            # AppSignal requires exception format for messages - this isn't a real exception
+            # but rather a way to send structured log messages through their error API
+            name: "LogMessage",  # Clear indication this is a log message
+            message: event.message,
+            backtrace: []  # No fake backtrace for log messages
+          },
+          tags: stringify_hash(event.context[:tags]),
+          params: stringify_hash(event.context[:params]),
+          environment: build_environment_context(event),
+          breadcrumbs: event.context[:breadcrumbs]
+        }
+      end
+
+      def build_environment_context(event)
+        {
+          "hostname" => Socket.gethostname,
+          "app_name" => @app_name,
+          "environment" => @environment
+        }.merge(stringify_hash(event.context[:environment] || {}))
+      end
+
+      def stringify_hash(hash)
+        (hash || {}).transform_keys(&:to_s).transform_values(&:to_s)
+      end
+
+      def validate_settings!
+        unless @push_api_key || @frontend_api_key
+          raise ValidationError, "AppSignal API key is required (either push_api_key or frontend_api_key)"
+        end
+
+        validate_api_key!(@push_api_key, "AppSignal push API key", format: :uuid) if @push_api_key
+        validate_api_key!(@frontend_api_key, "AppSignal frontend API key", format: :uuid) if @frontend_api_key
+        validate_presence!(@app_name, "AppSignal app name") if @app_name
+        validate_environment!(@environment, "AppSignal environment") if @environment
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/base.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "../http_client"
+require_relative "../validators"
+
+module Lapsoss
+  module Adapters
+    class Base
+      include Validators
+
+      attr_reader :name, :settings
+
+      def initialize(name, settings = {})
+        @name = name
+        @settings = settings
+        @enabled = true
+        configure_sdk
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def enable!
+        @enabled = true
+      end
+
+      def disable!
+        @enabled = false
+      end
+
+      def capabilities
+        {
+          errors: true,
+          performance: false,
+          sessions: false,
+          feature_flags: false,
+          check_ins: false,
+          breadcrumbs: false,
+          deployments: false,
+          metrics: false,
+          profiling: false,
+          security: false,
+          code_context: false,
+          data_scrubbing: false
+        }
+      end
+
+      def supports?(capability)
+        capabilities[capability] == true
+      end
+
+      def capture(event)
+        raise NotImplementedError, "#{self.class.name} must implement #capture"
+      end
+
+      def flush(timeout: 2)
+        # Optional implementation for flushing pending events
+      end
+
+      def shutdown
+        @enabled = false
+      end
+
+      private
+
+      def configure_sdk
+        # Override in subclass to configure vendor SDK
+      end
+
+      def create_http_client(uri, custom_config = {})
+        config = Lapsoss.configuration
+
+        transport_config = {
+          timeout: config.transport_timeout,
+          max_retries: config.transport_max_retries,
+          initial_backoff: config.transport_initial_backoff,
+          max_backoff: config.transport_max_backoff,
+          backoff_multiplier: config.transport_backoff_multiplier,
+          jitter: config.transport_jitter,
+          ssl_verify: config.transport_ssl_verify
+        }.merge(custom_config)
+
+        HttpClient.new(uri, transport_config)
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/insight_hub_adapter.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require_relative "../http_client"
+require_relative "../backtrace_processor"
+
+module Lapsoss
+  module Adapters
+    # Adapter for Insight Hub (formerly Bugsnag)
+    # Note: The API endpoints still use bugsnag.com domains for backwards compatibility
+    class InsightHubAdapter < Base
+      NOTIFY_URI = "https://notify.bugsnag.com"
+      SESSION_URI = "https://sessions.bugsnag.com"
+      JSON_CONTENT_TYPE = "application/json"
+
+      def initialize(name, settings = {})
+        super(name, settings)
+        @api_key = settings[:api_key] || ENV["INSIGHT_HUB_API_KEY"] || ENV["BUGSNAG_API_KEY"]
+        @release_stage = settings[:release_stage] || Lapsoss.configuration.environment
+        @app_version = settings[:app_version]
+        @app_type = settings[:app_type] || "ruby"
+
+        validate_settings!
+
+        @notify_client = create_http_client(NOTIFY_URI)
+        @session_client = create_http_client(SESSION_URI) if settings[:enable_sessions]
+        @backtrace_processor = BacktraceProcessor.new
+      end
+
+      def capture(event)
+        return unless enabled?
+
+        payload = build_payload(event)
+        return unless payload
+
+        headers = {
+          "Content-Type" => JSON_CONTENT_TYPE,
+          "Bugsnag-Api-Key" => @api_key,
+          "Bugsnag-Payload-Version" => "5.0",
+          "Bugsnag-Sent-At" => Time.now.utc.iso8601
+        }
+
+        begin
+          @notify_client.post("/", body: JSON.generate(payload), headers: headers)
+        rescue DeliveryError => e
+          # Log the error and potentially notify error handler
+          Lapsoss.configuration.logger&.error("[Lapsoss::InsightHubAdapter] Failed to deliver event: #{e.message}")
+          Lapsoss.configuration.error_handler&.call(e)
+
+          # Re-raise to let the caller know delivery failed
+          raise
+        end
+      end
+
+      def shutdown
+        @notify_client&.shutdown
+        @session_client&.shutdown
+        super
+      end
+
+      def capabilities
+        super.merge(
+          code_context: true,
+          breadcrumbs: true,
+          sessions: true
+        )
+      end
+
+      private
+
+      def build_payload(event)
+        {
+          apiKey: @api_key,
+          payloadVersion: "5.0",
+          notifier: {
+            name: "Lapsoss",
+            version: Lapsoss::VERSION,
+            url: "https://github.com/seuros/lapsoss"
+          },
+          events: [build_event(event)]
+        }
+      end
+
+      def build_event(event)
+        base_event = {
+          app: {
+            version: @app_version,
+            releaseStage: @release_stage,
+            type: @app_type
+          },
+          device: {
+            hostname: Socket.gethostname,
+            runtimeVersions: {
+              ruby: RUBY_VERSION
+            }
+          },
+          severity: map_severity(event.level),
+          unhandled: event.context[:unhandled] || false,
+          severityReason: {
+            type: event.context[:unhandled] ? "unhandledException" : "handledException"
+          },
+          user: build_user(event),
+          context: event.context[:context],
+          groupingHash: event.context[:fingerprint],
+          breadcrumbs: build_breadcrumbs(event),
+          metaData: event.context[:extra] || {}
+        }
+
+        case event.type
+        when :exception
+          base_event.merge(build_exception_data(event))
+        when :message
+          base_event.merge(build_message_data(event))
+        end
+      end
+
+      def build_exception_data(event)
+        {
+          exceptions: [{
+            errorClass: event.exception.class.name,
+            message: event.exception.message,
+            stacktrace: build_stacktrace(event.exception),
+            type: "ruby"
+          }]
+        }
+      end
+
+      def build_message_data(event)
+        {
+          exceptions: [{
+            # Insight Hub (Bugsnag) requires exception format for messages - this isn't a real exception
+            # but rather a way to send structured log messages through their error API
+            errorClass: "LogMessage",  # Clear indication this is a log message
+            message: event.message,
+            stacktrace: [],  # No fake backtrace for log messages
+            type: "log"      # Mark as log type, not ruby exception
+          }]
+        }
+      end
+
+      def build_stacktrace(exception)
+        return [] unless exception
+
+        frames = @backtrace_processor.process_exception(exception)
+        @backtrace_processor.format_frames(frames, :bugsnag)
+      end
+
+
+      def build_breadcrumbs(event)
+        breadcrumbs = event.context[:breadcrumbs] || []
+        breadcrumbs.map do |crumb|
+          {
+            timestamp: crumb[:timestamp]&.iso8601 || Time.now.utc.iso8601,
+            name: crumb[:message] || crumb[:name],
+            type: crumb[:type] || "manual",
+            metaData: crumb[:data] || {}
+          }
+        end
+      end
+
+      def build_user(event)
+        user = event.context[:user]
+        return unless user
+
+        {
+          id: user[:id]&.to_s,
+          name: user[:username] || user[:name],
+          email: user[:email]
+        }.compact
+      end
+
+      def map_severity(level)
+        case level
+        when :debug, :info then "info"
+        when :warning, :warn then "warning"
+        when :error, :fatal, :critical then "error"
+        else "error"
+        end
+      end
+
+      def validate_settings!
+        validate_presence!(@api_key, "Insight Hub API key")
+        validate_api_key!(@api_key, "Insight Hub API key", format: :alphanumeric) if @api_key
+        validate_environment!(@app_version, "Insight Hub app version") if @app_version
+        validate_type!(@release_stage, [String, Symbol], "Insight Hub release stage") if @release_stage
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/logger_adapter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Lapsoss
+  module Adapters
+    class LoggerAdapter < Base
+      def initialize(name, settings = {})
+        @logger = settings[:logger] || Logger.new($stdout)
+        super(name, settings)
+      end
+
+      def capabilities
+        super.merge(
+          breadcrumbs: true
+        )
+      end
+
+      def capture(event)
+        case event.type
+        when :exception
+          @logger.error(format_exception(event.exception, event.context))
+        when :message
+          logger_level = map_level(event.level)
+          @logger.send(logger_level, format_message(event.message, event.context))
+        else
+          @logger.info("[LAPSOSS] Unhandled event type: #{event.type.inspect} | Event: #{event.to_h.inspect}")
+        end
+
+        # Log breadcrumbs if present in the event context
+        if event.context[:breadcrumbs]&.any?
+          event.context[:breadcrumbs].each do |breadcrumb|
+            breadcrumb_msg = "[BREADCRUMB] [#{breadcrumb[:type].upcase}] #{breadcrumb[:message]}"
+            breadcrumb_msg += " | #{breadcrumb[:metadata].inspect}" unless breadcrumb[:metadata].empty?
+            @logger.debug(breadcrumb_msg)
+          end
+        end
+      end
+
+      private
+
+      def format_exception(exception, context)
+        message = "[LAPSOSS] Exception: #{exception.class}: #{exception.message}"
+        message += "\n#{exception.backtrace.first(10).join("\n")}" if exception.backtrace
+        message += "\nContext: #{context.inspect}" unless context.empty?
+        message
+      end
+
+      def format_message(message, context)
+        msg = "[LAPSOSS] #{message}"
+        msg += " | Context: #{context.inspect}" unless context.empty?
+        msg
+      end
+
+      def map_level(level)
+        case level
+        when :debug then :debug
+        when :info then :info
+        when :warn, :warning then :warn
+        when :error then :error
+        when :fatal then :fatal
+        else :info
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/rollbar_adapter.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "securerandom"
+require_relative "../http_client"
+require_relative "../backtrace_processor"
+
+module Lapsoss
+  module Adapters
+    class RollbarAdapter < Base
+      API_URI = "https://api.rollbar.com"
+      API_VERSION = "1"
+      JSON_CONTENT_TYPE = "application/json"
+
+      def initialize(name, settings = {})
+        super(name, settings)
+        @access_token = settings[:access_token] || ENV["ROLLBAR_ACCESS_TOKEN"]
+        @environment = settings[:environment] || Lapsoss.configuration.environment || "development"
+
+        validate_settings!
+
+        @client = create_http_client(API_URI)
+        @backtrace_processor = BacktraceProcessor.new
+      end
+
+      def capture(event)
+        return unless enabled?
+
+        payload = build_payload(event)
+        return unless payload
+
+        path = "/api/#{API_VERSION}/item/"
+        headers = {
+          "Content-Type" => JSON_CONTENT_TYPE,
+          "X-Rollbar-Access-Token" => @access_token
+        }
+
+        begin
+          @client.post(path, body: JSON.generate(payload), headers: headers)
+        rescue DeliveryError => e
+          # Log the error and potentially notify error handler
+          Lapsoss.configuration.logger&.error("[Lapsoss::RollbarAdapter] Failed to deliver event: #{e.message}")
+          Lapsoss.configuration.error_handler&.call(e)
+
+          # Re-raise to let the caller know delivery failed
+          raise
+        end
+      end
+
+      def shutdown
+        @client&.shutdown
+        super
+      end
+
+      def capabilities
+        super.merge(
+          code_context: true
+        )
+      end
+
+      private
+
+      def build_payload(event)
+        data = {
+          environment: @environment,
+          body: build_body(event),
+          level: map_level(event.level),
+          timestamp: event.timestamp.to_i,
+          platform: "ruby",
+          language: "ruby",
+          framework: detect_framework,
+          context: event.context[:context],
+          request: event.context[:request],
+          person: build_person(event),
+          custom: event.context[:extra] || {},
+          title: event.message || (event.exception&.message if event.type == :exception),
+          uuid: SecureRandom.uuid,
+          notifier: {
+            name: "lapsoss",
+            version: Lapsoss::VERSION
+          }
+        }
+
+        # Only add fingerprint if it exists
+        data[:fingerprint] = event.context[:fingerprint].to_s if event.context[:fingerprint]
+
+        { data: data }
+      end
+
+      def build_body(event)
+        case event.type
+        when :exception
+          {
+            trace: {
+              frames: build_backtrace_frames(event.exception),
+              exception: {
+                class: event.exception.class.name,
+                message: event.exception.message,
+                description: event.exception.message
+              }
+            }
+          }
+        when :message
+          {
+            message: {
+              body: event.message
+            }
+          }
+        end
+      end
+
+      def build_backtrace_frames(exception)
+        return [] unless exception
+
+        frames = @backtrace_processor.process_exception(exception, follow_cause: true)
+        formatted_frames = @backtrace_processor.format_frames(frames, :rollbar)
+        # Rollbar expects frames in reverse order (most recent first)
+        formatted_frames.reverse
+      end
+
+      def build_person(event)
+        user = event.context[:user]
+        return unless user
+
+        {
+          id: user[:id]&.to_s,
+          username: user[:username],
+          email: user[:email]
+        }.compact
+      end
+
+      def map_level(level)
+        case level
+        when :debug then "debug"
+        when :info then "info"
+        when :warning, :warn then "warning"
+        when :error then "error"
+        when :fatal, :critical then "critical"
+        else "error"
+        end
+      end
+
+      def detect_framework
+        return "rails" if defined?(Rails)
+        return "sinatra" if defined?(Sinatra)
+        "ruby"
+      end
+
+      def validate_settings!
+        validate_presence!(@access_token, "Rollbar access token")
+        validate_api_key!(@access_token, "Rollbar access token", format: :alphanumeric) if @access_token
+        validate_environment!(@environment, "Rollbar environment") if @environment
+      end
+    end
+  end
+end