streess 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cda80db362d88dec67489e6937f7f26d2807e5c7608b7ed92e1af8abee6be823
+  data.tar.gz: 837cc29a0b2fdfdbf599bd431624c8c5b44ed4d48ff86324a2ed04f33312b266
+SHA512:
+  metadata.gz: 49ddc166f17ed38c848e826945d882fb19207b94dc17b9a5b87f68ed0818a1526ab41041672f91c21cb2d742e04e0eaa07e374093311272973b0ea4cc6ce72ae
+  data.tar.gz: f4bd772562879ddaba889e61051a864da5f8e6153d973b1a47f906621830e29873470e244c8249754733b618cbfe393381413e3ddf3f7bf2e65b621aba505a59

data/lib/streess/client.rb

@@ -0,0 +1,50 @@
+require "net/http"
+require "uri"
+require "json"
+
+module Streess
+  class Client
+    class << self
+      # Test hook: set to a lambda to intercept HTTP calls
+      attr_accessor :http_handler
+
+      def send_error(payload)
+        config = Streess.configuration
+        uri = URI.join(config.endpoint, "/api/v1/errors")
+
+        request = Net::HTTP::Post.new(uri.path)
+        request["Content-Type"] = "application/json"
+        request["X-Streess-Key"] = config.api_key
+        request.body = JSON.generate(payload)
+
+        response = perform_request(uri, request)
+        response.code == "201"
+      rescue => e
+        log_error("Streess: failed to send error - #{e.class}: #{e.message}")
+        false
+      end
+
+      private
+
+      def perform_request(uri, request)
+        if http_handler
+          return http_handler.call(uri, request)
+        end
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = 5
+        http.read_timeout = 5
+        http.request(request)
+      end
+
+      def log_error(message)
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.error(message)
+        else
+          $stderr.puts(message)
+        end
+      end
+    end
+  end
+end

data/lib/streess/configuration.rb

@@ -0,0 +1,14 @@
+module Streess
+  class Configuration
+    attr_accessor :api_key, :endpoint, :current_user, :filtered_params
+
+    DEFAULT_FILTERED_PARAMS = [ :password, :token, :secret ].freeze
+
+    def initialize
+      @api_key = nil
+      @endpoint = nil
+      @current_user = nil
+      @filtered_params = DEFAULT_FILTERED_PARAMS.dup
+    end
+  end
+end

data/lib/streess/middleware.rb

@@ -0,0 +1,30 @@
+require_relative "../streess"
+require_relative "payload_builder"
+require_relative "client"
+
+module Streess
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      report_error(exception, env)
+      raise
+    end
+
+    private
+
+    def report_error(exception, env)
+      config = Streess.configuration
+      return unless config.api_key && !config.api_key.empty?
+
+      payload = PayloadBuilder.build(exception, env)
+      Client.send_error(payload)
+    rescue
+      # Never interfere with the original exception propagation
+    end
+  end
+end

data/lib/streess/param_filter.rb

@@ -0,0 +1,29 @@
+module Streess
+  class ParamFilter
+    FILTERED_VALUE = "[FILTERED]"
+
+    def initialize(filtered_keys = [])
+      @filtered_keys = filtered_keys.map { |k| k.to_s.downcase }
+    end
+
+    def filter(hash)
+      return hash unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) do |(key, value), result|
+        if filtered_key?(key)
+          result[key] = FILTERED_VALUE
+        elsif value.is_a?(Hash)
+          result[key] = filter(value)
+        else
+          result[key] = value
+        end
+      end
+    end
+
+    private
+
+    def filtered_key?(key)
+      @filtered_keys.include?(key.to_s.downcase)
+    end
+  end
+end

data/lib/streess/payload_builder.rb

@@ -0,0 +1,94 @@
+require_relative "param_filter"
+
+module Streess
+  class PayloadBuilder
+    BACKTRACE_REGEX = /^(.+):(\d+):in '?(.+?)'?$/
+
+    class << self
+      def build(exception, env)
+        filter = ParamFilter.new(Streess.configuration.filtered_params)
+
+        {
+          error: {
+            exception_class: exception.class.name,
+            message: exception.message,
+            occurred_at: Time.now.iso8601,
+            backtrace: parse_backtrace(exception),
+            request: build_request(env, filter),
+            client: build_client(env),
+            user: build_user(env),
+            environment: build_environment
+          }
+        }
+      end
+
+      private
+
+      def parse_backtrace(exception)
+        return [] unless exception.backtrace
+
+        exception.backtrace.map do |line|
+          match = line.match(BACKTRACE_REGEX)
+          if match
+            { file: match[1], line: match[2].to_i, method: match[3] }
+          else
+            { file: line, line: 0, method: "unknown" }
+          end
+        end
+      end
+
+      def build_request(env, filter)
+        params = extract_params(env)
+
+        {
+          method: env["REQUEST_METHOD"],
+          path: env["PATH_INFO"],
+          host: env["HTTP_HOST"] || env["SERVER_NAME"],
+          query_string: env["QUERY_STRING"],
+          params: filter.filter(params),
+          headers: extract_headers(env)
+        }
+      end
+
+      def extract_params(env)
+        params = {}
+        params.merge!(env["rack.request.form_hash"]) if env["rack.request.form_hash"].is_a?(Hash)
+        params.merge!(env["rack.request.query_hash"]) if env["rack.request.query_hash"].is_a?(Hash)
+        params
+      end
+
+      def extract_headers(env)
+        env.each_with_object({}) do |(key, value), headers|
+          next unless key.is_a?(String) && key.start_with?("HTTP_")
+          next if key == "HTTP_HOST"
+
+          header_name = key.sub("HTTP_", "").split("_").map(&:capitalize).join("-")
+          headers[header_name] = value
+        end
+      end
+
+      def build_client(env)
+        {
+          user_agent: env["HTTP_USER_AGENT"],
+          ip_address: env["REMOTE_ADDR"]
+        }
+      end
+
+      def build_user(env)
+        user_proc = Streess.configuration.current_user
+        return nil unless user_proc
+
+        user_proc.call(env)
+      rescue
+        nil
+      end
+
+      def build_environment
+        {
+          ruby_version: RUBY_VERSION,
+          ruby_platform: RUBY_PLATFORM
+        }
+      end
+    end
+  end
+end

data/lib/streess/railtie.rb

@@ -0,0 +1,15 @@
+require_relative "../streess"
+require_relative "middleware"
+
+module Streess
+  if defined?(Rails::Railtie)
+    class Railtie < Rails::Railtie
+      # Insert middleware during config phase (before the stack freezes).
+      # The middleware itself checks if api_key is configured at request
+      # time, so it's safe to insert unconditionally.
+      initializer "streess.insert_middleware" do |app|
+        app.config.middleware.use(Streess::Middleware)
+      end
+    end
+  end
+end

data/lib/streess-ruby.rb

@@ -0,0 +1,2 @@
+require_relative "streess"
+require_relative "streess/railtie"

data/lib/streess.rb

@@ -0,0 +1,17 @@
+require_relative "streess/configuration"
+
+module Streess
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration!
+      @configuration = nil
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: streess
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kasper Høglund
+bindir: bin
+cert_chain: []
+date: 2026-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Rack middleware and client library for reporting errors to a Streess
+  server.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/streess-ruby.rb
+- lib/streess.rb
+- lib/streess/client.rb
+- lib/streess/configuration.rb
+- lib/streess/middleware.rb
+- lib/streess/param_filter.rb
+- lib/streess/payload_builder.rb
+- lib/streess/railtie.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Ruby client for Streess error tracking
+test_files: []