lapsoss 0.2.0 → 0.3.0

data/lib/lapsoss/adapters/appsignal_adapter.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'socket'
+require "json"
+require "socket"
 
 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'
+      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
-        @push_api_key = settings[:push_api_key] || ENV.fetch('APPSIGNAL_PUSH_API_KEY', nil)
-        @frontend_api_key = settings[:frontend_api_key] || ENV.fetch('APPSIGNAL_FRONTEND_API_KEY', nil)
-        @app_name = settings[:app_name] || ENV.fetch('APPSIGNAL_APP_NAME', nil)
+        @push_api_key = settings[:push_api_key] || ENV.fetch("APPSIGNAL_PUSH_API_KEY", nil)
+        @frontend_api_key = settings[:frontend_api_key] || ENV.fetch("APPSIGNAL_FRONTEND_API_KEY", nil)
+        @app_name = settings[:app_name] || ENV.fetch("APPSIGNAL_APP_NAME", nil)
         @environment = Lapsoss.configuration.environment
 
         validate_settings!
@@ -30,7 +30,7 @@ module Lapsoss
         return unless payload
 
         path = "/errors?api_key=#{@frontend_api_key}"
-        headers = { 'Content-Type' => JSON_CONTENT_TYPE }
+        headers = { "Content-Type" => JSON_CONTENT_TYPE }
 
         begin
           @errors_client.post(path, body: JSON.generate(payload), headers: headers)
@@ -64,7 +64,7 @@ module Lapsoss
       def build_exception_payload(event)
         {
           timestamp: event.timestamp.to_i,
-          namespace: event.context[:namespace] || 'backend',
+          namespace: event.context[:namespace] || "backend",
           error: {
             name: event.exception.class.name,
             message: event.exception.message,
@@ -86,18 +86,18 @@ module Lapsoss
           # 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'
+            "AppSignal only supports :error, :fatal, and :critical levels for messages"
           )
           return nil
         end
 
         {
-          action: event.context[:action] || 'log_message',
-          path: event.context[:path] || '/',
+          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
+            name: "LogMessage", # Clear indication this is a log message
             message: event.message,
             backtrace: [] # No fake backtrace for log messages
           },
@@ -110,9 +110,9 @@ module Lapsoss
 
       def build_environment_context(event)
         {
-          'hostname' => Socket.gethostname,
-          'app_name' => @app_name,
-          'environment' => @environment
+          "hostname" => Socket.gethostname,
+          "app_name" => @app_name,
+          "environment" => @environment
         }.merge(stringify_hash(event.context[:environment] || {}))
       end
 
@@ -122,13 +122,13 @@ module Lapsoss
 
       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)'
+          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
+        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

data/lib/lapsoss/adapters/base.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../http_client'
-require_relative '../validators'
-
 module Lapsoss
   module Adapters
     class Base

data/lib/lapsoss/adapters/insight_hub_adapter.rb

@@ -1,28 +1,20 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'socket'
+require "json"
 
 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'
+      API_URI = "https://notify.bugsnag.com"
+      JSON_CONTENT_TYPE = "application/json"
 
       def initialize(name, settings = {})
         super
-        @api_key = settings[:api_key] || ENV['INSIGHT_HUB_API_KEY'] || ENV.fetch('BUGSNAG_API_KEY', nil)
-        @release_stage = settings[:release_stage] || Lapsoss.configuration.environment
-        @app_version = settings[:app_version]
-        @app_type = settings[:app_type] || 'ruby'
+        @api_key = settings[:api_key] || ENV.fetch("INSIGHT_HUB_API_KEY", nil)
 
         validate_settings!
 
-        @notify_client = create_http_client(NOTIFY_URI)
-        @session_client = create_http_client(SESSION_URI) if settings[:enable_sessions]
+        @client = create_http_client(API_URI)
         @backtrace_processor = BacktraceProcessor.new
       end
 
@@ -32,133 +24,113 @@ module Lapsoss
         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
+        response = @client.post("/", body: payload.to_json, headers: {
+                                  "Content-Type" => JSON_CONTENT_TYPE,
+                                  "Bugsnag-Api-Key" => @api_key,
+                                  "Bugsnag-Payload-Version" => "5"
+                                })
 
-      def shutdown
-        @notify_client&.shutdown
-        @session_client&.shutdown
-        super
+        handle_response(response, event)
+      rescue StandardError => e
+        handle_delivery_error(e)
       end
 
       def capabilities
         super.merge(
-          code_context: true,
           breadcrumbs: true,
+          user_tracking: true,
+          custom_context: true,
+          release_tracking: true,
           sessions: true
         )
       end
 
+      def validate!
+        validate_settings!
+        true
+      end
+
       private
 
       def build_payload(event)
         {
           apiKey: @api_key,
-          payloadVersion: '5.0',
+          payloadVersion: "5",
           notifier: {
-            name: 'Lapsoss',
+            name: "Lapsoss Ruby",
             version: Lapsoss::VERSION,
-            url: 'https://github.com/seuros/lapsoss'
+            url: "https://github.com/yourusername/lapsoss"
           },
-          events: [build_event(event)]
+          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
-            }
-          },
+        {
+          app: build_app_data(event),
+          device: build_device_data,
+          exceptions: build_exceptions(event),
+          breadcrumbs: build_breadcrumbs(event),
+          request: event.request_context,
+          user: build_user_data(event),
+          context: event.context[:custom]&.dig(:context) || "production",
           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] || {}
-        }
+          metaData: event.context[:custom] || {}
+        }.compact
+      end
 
-        case event.type
-        when :exception
-          base_event.merge(build_exception_data(event))
-        when :message
-          base_event.merge(build_message_data(event))
-        end
+      def build_exceptions(event)
+        return [] unless event.type == :exception && event.exception
+
+        [ {
+          errorClass: event.exception_type,
+          message: event.message,
+          stacktrace: build_stacktrace(event.exception),
+          type: "ruby"
+        } ]
       end
 
-      def build_exception_data(event)
-        {
-          exceptions: [{
-            errorClass: event.exception.class.name,
-            message: event.exception.message,
-            stacktrace: build_stacktrace(event.exception),
-            type: 'ruby'
-          }]
-        }
+      def build_stacktrace(exception)
+        frames = @backtrace_processor.process_exception(exception, follow_cause: true)
+        @backtrace_processor.format_frames(frames, :bugsnag)
       end
 
-      def build_message_data(event)
+      def build_app_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
-          }]
-        }
+          id: event.context[:app]&.dig(:id),
+          version: event.context[:release]&.dig(:version),
+          releaseStage: @environment || "production",
+          type: detect_app_type
+        }.compact
       end
 
-      def build_stacktrace(exception)
-        return [] unless exception
-
-        frames = @backtrace_processor.process_exception(exception)
-        @backtrace_processor.format_frames(frames, :bugsnag)
+      def build_device_data
+        {
+          hostname: Socket.gethostname,
+          osName: RUBY_PLATFORM,
+          runtimeVersions: {
+            ruby: RUBY_VERSION
+          }
+        }
       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',
+            timestamp: crumb[:timestamp]&.iso8601,
+            name: crumb[:message],
+            type: crumb[:type] || "manual",
             metaData: crumb[:data] || {}
           }
         end
       end
 
-      def build_user(event)
+      def build_user_data(event)
         user = event.context[:user]
-        return unless user
+        return nil unless user
 
         {
           id: user[:id]&.to_s,
@@ -169,18 +141,50 @@ module Lapsoss
 
       def map_severity(level)
         case level
-        when :debug, :info then 'info'
-        when :warning, :warn then 'warning'
-        when :error, :fatal, :critical then 'error'
-        else 'error'
+        when :debug, :info then "info"
+        when :warning then "warning"
+        when :error, :fatal then "error"
+        else "error"
+        end
+      end
+
+      def detect_app_type
+        return "rails" if defined?(Rails)
+        return "rack" if defined?(Rack)
+
+        "ruby"
+      end
+
+      def handle_response(response, _event)
+        case response.status
+        when 200
+          true
+        when 400
+          body = begin
+            JSON.parse(response.body)
+          rescue
+            {}
+          end
+          raise DeliveryError.new("Bad request: #{body['errors']&.join(', ')}", response: response)
+        when 401
+          raise DeliveryError.new("Unauthorized: Invalid API key", response: response)
+        when 413
+          raise DeliveryError.new("Payload too large", response: response)
+        when 429
+          raise DeliveryError.new("Rate limit exceeded", response: response)
+        else
+          raise DeliveryError.new("Unexpected response: #{response.status}", response: response)
         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
+        validate_presence!(@api_key, "Insight Hub API key")
+        validate_api_key!(@api_key, "Insight Hub API key", format: :alphanumeric) if @api_key
+      end
+
+      def handle_delivery_error(error, response = nil)
+        message = "Insight Hub delivery failed: #{error.message}"
+        raise DeliveryError.new(message, response: response, cause: error)
       end
     end
   end

data/lib/lapsoss/adapters/logger_adapter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module Lapsoss
   module Adapters

data/lib/lapsoss/adapters/rollbar_adapter.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'socket'
-require 'securerandom'
+require "json"
+require "socket"
+require "securerandom"
 
 module Lapsoss
   module Adapters
     class RollbarAdapter < Base
-      API_URI = 'https://api.rollbar.com'
-      API_VERSION = '1'
-      JSON_CONTENT_TYPE = 'application/json'
+      API_URI = "https://api.rollbar.com"
+      API_VERSION = "1"
+      JSON_CONTENT_TYPE = "application/json"
 
       def initialize(name, settings = {})
         super
-        @access_token = settings[:access_token] || ENV.fetch('ROLLBAR_ACCESS_TOKEN', nil)
-        @environment = settings[:environment] || Lapsoss.configuration.environment || 'development'
+        @access_token = settings[:access_token] || ENV.fetch("ROLLBAR_ACCESS_TOKEN", nil)
+        @environment = settings[:environment] || Lapsoss.configuration.environment || "development"
 
         validate_settings!
 
@@ -28,62 +28,50 @@ module Lapsoss
         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
+        response = @client.post("/api/#{API_VERSION}/item/", body: payload.to_json, headers: {
+                                  "Content-Type" => JSON_CONTENT_TYPE,
+                                  "X-Rollbar-Access-Token" => @access_token
+                                })
 
-      def shutdown
-        @client&.shutdown
-        super
+        handle_response(response, event)
+      rescue StandardError => e
+        handle_delivery_error(e)
       end
 
       def capabilities
         super.merge(
-          code_context: true
+          breadcrumbs: true,
+          user_tracking: true,
+          custom_context: true,
+          release_tracking: true
         )
       end
 
+      def validate!
+        validate_settings!
+        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
+        {
+          access_token: @access_token,
+          data: {
+            environment: @environment,
+            body: build_body(event),
+            level: map_level(event.level),
+            timestamp: event.timestamp.to_i,
+            code_version: event.context[:release]&.dig(:commit_sha),
+            platform: "ruby",
+            language: "ruby",
+            framework: detect_framework,
+            server: build_server_data,
+            person: build_person_data(event),
+            request: event.request_context,
+            custom: event.context[:custom] || {}
           }
         }
-
-        # Only add fingerprint if it exists
-        data[:fingerprint] = event.context[:fingerprint].to_s if event.context[:fingerprint]
-
-        { data: data }
       end
 
       def build_body(event)
@@ -93,9 +81,9 @@ module Lapsoss
             trace: {
               frames: build_backtrace_frames(event.exception),
               exception: {
-                class: event.exception.class.name,
-                message: event.exception.message,
-                description: event.exception.message
+                class: event.exception_type,
+                message: event.message,
+                description: event.exception.to_s
               }
             }
           }
@@ -117,9 +105,9 @@ module Lapsoss
         formatted_frames.reverse
       end
 
-      def build_person(event)
+      def build_person_data(event)
         user = event.context[:user]
-        return unless user
+        return nil unless user
 
         {
           id: user[:id]&.to_s,
@@ -128,28 +116,80 @@ module Lapsoss
         }.compact
       end
 
+      def build_server_data
+        {
+          host: Socket.gethostname,
+          root: defined?(Rails) ? Rails.root.to_s : Dir.pwd,
+          branch: git_branch,
+          code_version: git_sha
+        }.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'
+        when :debug then "debug"
+        when :info then "info"
+        when :warning then "warning"
+        when :error then "error"
+        when :fatal then "critical"
+        else "error"
         end
       end
 
       def detect_framework
-        return 'rails' if defined?(Rails)
-        return 'sinatra' if defined?(Sinatra)
+        return "rails" if defined?(Rails)
+        return "sinatra" if defined?(Sinatra)
+
+        "ruby"
+      end
+
+      def git_branch
+        `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip.presence
+      rescue StandardError
+        nil
+      end
+
+      def git_sha
+        `git rev-parse HEAD 2>/dev/null`.strip.presence
+      rescue StandardError
+        nil
+      end
 
-        'ruby'
+      def handle_response(response, event)
+        case response.code.to_i
+        when 200
+          true
+        when 400
+          handle_client_error(response, event)
+        when 401
+          raise DeliveryError.new("Unauthorized: Invalid access token", response: response)
+        when 429
+          raise DeliveryError.new("Rate limit exceeded", response: response)
+        else
+          raise DeliveryError.new("Unexpected response: #{response.code}", response: response)
+        end
+      end
+
+      def handle_client_error(response, _event)
+        body = begin
+          JSON.parse(response.body)
+        rescue
+          {}
+        end
+        error_msg = body["message"] || "Bad request"
+
+        raise DeliveryError.new("Client error: #{error_msg}", response: response)
       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
+        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
+
+      def handle_delivery_error(error, response = nil)
+        message = "Rollbar delivery failed: #{error.message}"
+        raise DeliveryError.new(message, response: response, cause: error)
       end
     end
   end