lapsoss 0.1.0

data/lib/lapsoss/http_client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "json"
+require "zlib"
+
+module Lapsoss
+  # HTTP client wrapper using Faraday with retry logic
+  class HttpClient
+    USER_AGENT = "lapsoss/#{Lapsoss::VERSION}"
+
+    def initialize(base_url, config = {})
+      @base_url = base_url
+      @config = config
+      @connection = build_connection
+    end
+
+    def post(path, body:, headers: {})
+      response = @connection.post(path) do |req|
+        req.body = body
+        req.headers.merge!(headers)
+      end
+
+      unless response.success?
+        raise DeliveryError.new(
+          "HTTP #{response.status}: #{response.reason_phrase}",
+          response: response
+        )
+      end
+
+      response
+    rescue Faraday::Error => e
+      raise DeliveryError.new(
+        "Network error: #{e.message}",
+        cause: e
+      )
+    end
+
+    def shutdown
+      # Faraday connections don't need explicit shutdown
+    end
+
+    private
+
+    def build_connection
+      Faraday.new(@base_url) do |conn|
+        # Configure retry middleware
+        conn.request :retry, retry_options
+
+        # Configure timeouts
+        conn.options.timeout = @config[:timeout] || 5
+        conn.options.open_timeout = @config[:timeout] || 5
+
+        # Configure SSL
+        if @config.key?(:ssl_verify)
+          conn.ssl.verify = @config[:ssl_verify]
+        end
+
+        # Set user agent
+        conn.headers["User-Agent"] = USER_AGENT
+
+        # Use default adapter
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def retry_options
+      {
+        max: @config[:max_retries] || 3,
+        interval: @config[:initial_backoff] || 1.0,
+        max_interval: @config[:max_backoff] || 64.0,
+        backoff_factor: @config[:backoff_multiplier] || 2.0,
+        retry_statuses: [408, 429, 500, 502, 503, 504],
+        methods: [:post]
+      }
+    end
+  end
+end

data/lib/lapsoss/middleware.rb

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    class Base
+      def initialize(app)
+        @app = app
+      end
+
+      def call(event, hint = {})
+        @app.call(event, hint)
+      end
+    end
+
+    # Built-in middleware for common functionality
+    class SampleFilter < Base
+      def initialize(app, sample_rate: 1.0, sample_callback: nil)
+        super(app)
+        @sample_rate = sample_rate
+        @sample_callback = sample_callback
+      end
+
+      def call(event, hint = {})
+        # Apply custom sampling logic first
+        if @sample_callback
+          return nil unless @sample_callback.call(event, hint)
+        end
+
+        # Apply rate-based sampling
+        if @sample_rate < 1.0
+          return nil if rand > @sample_rate
+        end
+
+        @app.call(event, hint)
+      end
+    end
+
+    class ExceptionFilter < Base
+      def initialize(app, excluded_exceptions: [], excluded_patterns: [])
+        super(app)
+        @excluded_exceptions = Array(excluded_exceptions)
+        @excluded_patterns = Array(excluded_patterns)
+      end
+
+      def call(event, hint = {})
+        return nil if should_exclude?(event)
+        @app.call(event, hint)
+      end
+
+      private
+
+      def should_exclude?(event)
+        return false unless event.exception
+
+        exception_class = event.exception.class
+        exception_message = event.exception.message
+
+        # Check exact class matches
+        return true if @excluded_exceptions.any? { |klass| exception_class <= klass }
+
+        # Check pattern matches
+        @excluded_patterns.any? do |pattern|
+          case pattern
+          when Regexp
+            exception_message&.match?(pattern) || exception_class.name.match?(pattern)
+          when String
+            exception_message&.include?(pattern) || exception_class.name.include?(pattern)
+          else
+            false
+          end
+        end
+      end
+    end
+
+    class UserContextEnhancer < Base
+      def initialize(app, user_provider: nil, privacy_mode: false)
+        super(app)
+        @user_provider = user_provider
+        @privacy_mode = privacy_mode
+      end
+
+      def call(event, hint = {})
+        enhance_user_context(event, hint)
+        @app.call(event, hint)
+      end
+
+      private
+
+      def enhance_user_context(event, hint)
+        # Get user from provider if available
+        user_data = @user_provider&.call(event, hint) || {}
+
+        # Merge with existing user context
+        existing_user = event.context[:user] || {}
+        enhanced_user = existing_user.merge(user_data)
+
+        # Apply privacy filtering if enabled
+        if @privacy_mode
+          enhanced_user = apply_privacy_filtering(enhanced_user)
+        end
+
+        event.context[:user] = enhanced_user unless enhanced_user.empty?
+      end
+
+      def apply_privacy_filtering(user_data)
+        # Remove sensitive fields in privacy mode
+        sensitive_fields = [:email, :phone, :address, :ssn, :credit_card]
+        filtered = user_data.dup
+
+        sensitive_fields.each do |field|
+          if filtered.key?(field)
+            filtered[field] = "[FILTERED]"
+          end
+        end
+
+        filtered
+      end
+    end
+
+    class ReleaseTracker < Base
+      def initialize(app, release_provider: nil)
+        super(app)
+        @release_provider = release_provider
+      end
+
+      def call(event, hint = {})
+        add_release_info(event, hint)
+        @app.call(event, hint)
+      end
+
+      private
+
+      def add_release_info(event, hint)
+        release_info = @release_provider&.call(event, hint) || auto_detect_release
+
+        if release_info
+          event.context[:release] = release_info
+        end
+      end
+
+      def auto_detect_release
+        release_info = {}
+
+        # Try to detect Git information
+        if git_info = detect_git_info
+          release_info.merge!(git_info)
+        end
+
+        # Try to detect deployment info
+        if deployment_info = detect_deployment_info
+          release_info.merge!(deployment_info)
+        end
+
+        release_info.empty? ? nil : release_info
+      end
+
+      def detect_git_info
+        return nil unless File.exist?(".git")
+
+        begin
+          # Get current commit SHA
+          commit_sha = `git rev-parse HEAD`.strip
+          return nil if commit_sha.empty?
+
+          # Get branch name
+          branch = `git rev-parse --abbrev-ref HEAD`.strip
+          branch = nil if branch.empty? || branch == "HEAD"
+
+          # Get commit timestamp
+          commit_time = `git log -1 --format=%ct`.strip
+          commit_timestamp = commit_time.empty? ? nil : Time.at(commit_time.to_i)
+
+          # Get tag if on a tag
+          tag = `git describe --exact-match --tags HEAD 2>/dev/null`.strip
+          tag = nil if tag.empty?
+
+          {
+            commit_sha: commit_sha,
+            branch: branch,
+            tag: tag,
+            commit_timestamp: commit_timestamp
+          }.compact
+        rescue StandardError
+          nil
+        end
+      end
+
+      def detect_deployment_info
+        info = {}
+
+        # Check common deployment environment variables
+        info[:deployment_id] = ENV["DEPLOYMENT_ID"] if ENV["DEPLOYMENT_ID"]
+        info[:build_number] = ENV["BUILD_NUMBER"] if ENV["BUILD_NUMBER"]
+        info[:deployment_time] = parse_deployment_time(ENV["DEPLOYMENT_TIME"]) if ENV["DEPLOYMENT_TIME"]
+
+        # Check Heroku
+        if ENV["HEROKU_APP_NAME"]
+          info[:platform] = "heroku"
+          info[:app_name] = ENV["HEROKU_APP_NAME"]
+          info[:dyno] = ENV["DYNO"]
+          info[:slug_commit] = ENV["HEROKU_SLUG_COMMIT"]
+        end
+
+        # Check AWS
+        if ENV["AWS_EXECUTION_ENV"]
+          info[:platform] = "aws"
+          info[:execution_env] = ENV["AWS_EXECUTION_ENV"]
+          info[:region] = ENV["AWS_REGION"]
+        end
+
+        # Check Docker
+        if ENV["DOCKER_CONTAINER_ID"] || File.exist?("/.dockerenv")
+          info[:platform] = "docker"
+          info[:container_id] = ENV["DOCKER_CONTAINER_ID"]
+        end
+
+        # Check Kubernetes
+        if ENV["KUBERNETES_SERVICE_HOST"]
+          info[:platform] = "kubernetes"
+          info[:namespace] = ENV["KUBERNETES_NAMESPACE"]
+          info[:pod_name] = ENV["HOSTNAME"]
+        end
+
+        info.empty? ? nil : info
+      end
+
+      def parse_deployment_time(time_str)
+        Time.parse(time_str)
+      rescue StandardError
+        nil
+      end
+    end
+
+    class EventEnricher < Base
+      def initialize(app, enrichers: [])
+        super(app)
+        @enrichers = enrichers
+      end
+
+      def call(event, hint = {})
+        @enrichers.each do |enricher|
+          enricher.call(event, hint)
+        end
+        @app.call(event, hint)
+      end
+    end
+
+    class ConditionalFilter < Base
+      def initialize(app, condition)
+        super(app)
+        @condition = condition
+      end
+
+      def call(event, hint = {})
+        return nil unless @condition.call(event, hint)
+        @app.call(event, hint)
+      end
+    end
+
+    class EventTransformer < Base
+      def initialize(app, transformer)
+        super(app)
+        @transformer = transformer
+      end
+
+      def call(event, hint = {})
+        transformed_event = @transformer.call(event, hint)
+        return nil unless transformed_event
+        @app.call(transformed_event, hint)
+      end
+    end
+
+    class RateLimiter < Base
+      def initialize(app, max_events: 100, time_window: 60)
+        super(app)
+        @max_events = max_events
+        @time_window = time_window
+        @events = []
+        @mutex = Mutex.new
+      end
+
+      def call(event, hint = {})
+        @mutex.synchronize do
+          now = Time.now
+          # Remove old events outside time window
+          @events.reject! { |timestamp| now - timestamp > @time_window }
+
+          # Check if we're over the limit
+          if @events.length >= @max_events
+            return nil
+          end
+
+          # Add current event
+          @events << now
+        end
+
+        @app.call(event, hint)
+      end
+    end
+
+    class MetricsCollector < Base
+      def initialize(app, collector: nil)
+        super(app)
+        @collector = collector
+        @metrics = {
+          events_processed: 0,
+          events_dropped: 0,
+          events_by_type: Hash.new(0),
+          events_by_level: Hash.new(0)
+        }
+        @mutex = Mutex.new
+      end
+
+      def call(event, hint = {})
+        @mutex.synchronize do
+          @metrics[:events_processed] += 1
+          @metrics[:events_by_type][event.type] += 1
+          @metrics[:events_by_level][event.level] += 1
+        end
+
+        result = @app.call(event, hint)
+
+        if result.nil?
+          @mutex.synchronize do
+            @metrics[:events_dropped] += 1
+          end
+        end
+
+        # Send to external collector if provided
+        @collector&.call(@metrics.dup, event, hint)
+
+        result
+      end
+
+      def metrics
+        @mutex.synchronize { @metrics.dup }
+      end
+    end
+
+    # Middleware wrapper for sampling strategies
+    class SamplingMiddleware < Base
+      def initialize(app, sampler)
+        super(app)
+        @sampler = sampler
+      end
+
+      def call(event, hint = {})
+        return nil unless @sampler.sample?(event, hint)
+        @app.call(event, hint)
+      end
+    end
+  end
+end

data/lib/lapsoss/pipeline.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "middleware"
+
+module Lapsoss
+  class Pipeline
+    def initialize
+      @middlewares = []
+      @built = false
+      @app = nil
+    end
+
+    def use(middleware_class, *args, **kwargs)
+      raise "Cannot modify pipeline after it's built" if @built
+
+      @middlewares << { class: middleware_class, args: args, kwargs: kwargs }
+      self
+    end
+
+    def build
+      return @app if @built
+
+      # Build the middleware chain from inside out
+      @app = build_chain
+      @built = true
+      @app
+    end
+
+    def call(event, hint = {})
+      build unless @built
+      @app.call(event, hint)
+    end
+
+    def reset
+      @middlewares.clear
+      @built = false
+      @app = nil
+      self
+    end
+
+    def middlewares
+      @middlewares.dup
+    end
+
+    private
+
+    def build_chain
+      # The final app just returns the event
+      final_app = lambda { |event, hint| event }
+
+      # Build middleware chain from right to left
+      @middlewares.reverse.reduce(final_app) do |app, middleware_config|
+        klass = middleware_config[:class]
+        args = middleware_config[:args]
+        kwargs = middleware_config[:kwargs]
+
+        klass.new(app, *args, **kwargs)
+      end
+    end
+  end
+
+  class PipelineBuilder
+    def initialize
+      @pipeline = Pipeline.new
+    end
+
+    def sample(rate: 1.0, &block)
+      @pipeline.use(Middleware::SampleFilter, sample_rate: rate, sample_callback: block)
+      self
+    end
+
+    def exclude_exceptions(*exception_classes, patterns: [])
+      @pipeline.use(Middleware::ExceptionFilter,
+                    excluded_exceptions: exception_classes,
+                    excluded_patterns: patterns)
+      self
+    end
+
+    def enhance_user_context(provider: nil, privacy_mode: false)
+      @pipeline.use(Middleware::UserContextEnhancer,
+                    user_provider: provider,
+                    privacy_mode: privacy_mode)
+      self
+    end
+
+    def track_releases(provider: nil)
+      @pipeline.use(Middleware::ReleaseTracker, release_provider: provider)
+      self
+    end
+
+    def rate_limit(max_events: 100, time_window: 60)
+      @pipeline.use(Middleware::RateLimiter,
+                    max_events: max_events,
+                    time_window: time_window)
+      self
+    end
+
+    def collect_metrics(collector: nil)
+      @pipeline.use(Middleware::MetricsCollector, collector: collector)
+      self
+    end
+
+    def enrich_events(*enrichers)
+      @pipeline.use(Middleware::EventEnricher, enrichers: enrichers)
+      self
+    end
+
+    def filter_if(&condition)
+      @pipeline.use(Middleware::ConditionalFilter, condition)
+      self
+    end
+
+    def transform_events(&transformer)
+      @pipeline.use(Middleware::EventTransformer, transformer)
+      self
+    end
+
+    def use_middleware(middleware_class, *args, **kwargs)
+      @pipeline.use(middleware_class, *args, **kwargs)
+      self
+    end
+
+    def build
+      @pipeline.build
+    end
+
+    def pipeline
+      @pipeline
+    end
+  end
+end

data/lib/lapsoss/railtie.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class Railtie < Rails::Railtie
+    config.lapsoss = ActiveSupport::OrderedOptions.new
+
+    initializer "lapsoss.configure" do |app|
+      Lapsoss.configure do |config|
+        config.environment ||= Rails.env
+        config.logger ||= Rails.logger
+        config.release ||= Rails.application.config.try(:release)
+
+        # Set default tags
+        config.default_tags = {
+          rails_env: Rails.env,
+          rails_version: Rails.version
+        }
+      end
+    end
+
+    initializer "lapsoss.rails_error_subscriber", after: "lapsoss.configure" do |app|
+      if Rails.version.to_f >= 7.0
+        app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
+      end
+    end
+
+
+
+    rake_tasks do
+      # Add any Lapsoss-specific rake tasks here
+    end
+  end
+
+  class RailsErrorSubscriber
+    def report(error, handled:, severity:, context:, source: nil)
+      # Skip certain framework errors
+      return if skip_error?(error, source)
+
+      level = map_severity(severity)
+
+      Lapsoss.capture_exception(
+        error,
+        level: level,
+        tags: {
+          handled: handled,
+          source: source || "rails"
+        },
+        context: context
+      )
+    end
+
+    private
+
+    def skip_error?(error, source)
+      # Skip cache-related Redis errors if configured to do so
+      if Lapsoss.configuration.skip_rails_cache_errors
+        return true if source&.include?("cache") && error.is_a?(Redis::CannotConnectError)
+      end
+
+      false
+    end
+
+    def map_severity(severity)
+      case severity
+      when :error then :error
+      when :warning then :warning
+      when :info then :info
+      else :error
+      end
+    end
+  end
+end