salopulse 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 508b79a0d71e8bf74c4c743df633f4c78d54607acf341587bcb6a29eeeb7f0c8
-  data.tar.gz: 9b27e52989cebcdaa7f6b48f4b9b758422c362c1e91fc3f93e35e3c26e06030f
+  metadata.gz: 0deb38c69a0976dd9139e0014a6b1af52635fa38c526a31f5fe8ab7ad3ec37ac
+  data.tar.gz: f9ec686f732520929bca77433c82fc11022aba9fecc22728e7f2ef849b843ed1
 SHA512:
-  metadata.gz: 9c6dd7aabc843b88d157244c9479ef89786d4efcf20c4b0db7330b596b259a5c9ede75e9bf491ed0e29459d60580d516794303274b97a99f8ebdc89159214278
-  data.tar.gz: 760dc6b01a270fcf26ee5e90a8ad1c60fbb7951168baa1bb9caf654526d7ea6ab3e2d1b09c84bcf5368962707c60530a2bf5b1ec13620bf9ba070571112b73a7
+  metadata.gz: c6d189bf5387cee4601ef5946ee5a74cd51355682184e7fb9f63aa8abcf4b8ef606072e9bfd38e7bf676c6010dba466c0c23b84f07c6807cea34da5d8c1864a4
+  data.tar.gz: 56e41da52bd09d63b852aec442b2ab148d2695c4c916b4d9a40ce462cfc4b4a739649adc36b9dc519c01d1c0d1d8c7c5899282497c48ce2cfd079e660a84c2d7

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [0.2.1] - 2026-06-04
+
+First public release of the rewritten Salopulse APM SDK. Bumped past the
+legacy `salopulse` 0.1.x line on RubyGems.
+
+### Added (since legacy 0.1.x)
+
+### Added
+- DSN parsing (`Salopulse::DSN`) with strict validation
+- Thread-safe `Buffer` with drop-on-overflow
+- `Transport` with retry/backoff (5xx + 429, max 3 attempts)
+- Background `Flusher` thread with interval + batch_size flushing
+- `RequestContext` (thread-local) for request_id correlation
+- ActiveRecord SQL subscriber with schema/transaction/cached filtering
+- Rack middleware for performance + exception capture
+- N+1 detection within request scope (`n1_threshold`)
+- PII `Sanitizer` for hash + header scrubbing
+- `before_send` and `sample_rate` hooks
+- Rails `Railtie` for automatic install
+- Graceful `at_exit` shutdown with final flush

data/LICENSE

@@ -1,28 +1,15 @@
-
----
-
-# 📄 **3. `LICENSE`
-
-```text
 MIT License
 
-Copyright (c) 2025 Salo Company
-All rights reserved.
+Copyright (c) 2026 Salopulse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights  
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-copies of the Software, and to permit persons to whom the Software is  
-furnished to do so, subject to the following conditions:  
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in  
-all copies or substantial portions of the Software.  
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

data/README.md

@@ -1,26 +1,82 @@
-# SaloPulse Ruby SDK
+# Salopulse Ruby SDK
 
-SaloPulse Ruby SDK, Ruby ve Ruby on Rails projeleri için geliştirilmiş hafif ve modern bir **monitoring & analytics entegrasyon kütüphanesidir**.
+Otomatik SQL, hata ve HTTP performans telemetrisi — Ruby uygulamaları için Salopulse APM istemcisi.
 
-Bu SDK, uygulamanızdaki her HTTP isteğini otomatik olarak izler, performans ölçer ve verileri **SaloPulse Observability Platformu**na güvenli bir şekilde iletir.
+## Kurulum
 
----
+```ruby
+# Gemfile
+gem "salopulse"
+```
+
+```
+bundle install
+```
 
-## 🚀 Özellikler
+## Hızlı Başlangıç
+
+```ruby
+# config/initializers/salopulse.rb
+Salopulse.init(dsn: ENV["SALOPULSE_DSN"])
+```
 
-- Otomatik request yakalama (middleware)
-- Path, method, status, response time ölçümü
-- IP & User-Agent toplama
-- API key tabanlı güvenli kimliklendirme
-- SaloPulse backend’e JSON gönderimi
-- Non-blocking – uygulamanızı hiçbir zaman bozmaz
-- Production-ready – enterprise sistemler için uygundur
+Rails varsa bu kadarı yeter — middleware ve ActiveRecord aboneliği otomatik kurulur.
 
----
+## Otomatik Yakalanan Olaylar
 
-## 📦 Kurulum
+- **SQL** — `ActiveSupport::Notifications` üzerinden her sorgu (schema/transaction/cached hariç)
+- **Hata** — Rack middleware'den sızan tüm exception'lar
+- **Performans** — Her HTTP request için süre + status
 
-### 1. Gem ekle
+## Manuel API
 
 ```ruby
-gem "salopulse"
+Salopulse.capture_exception(error, user_context: { user_id: 1 })
+Salopulse.capture_message("cache miss", level: :warning)
+Salopulse.set_user(id: 1, email: "a@b.com")
+Salopulse.set_tag(:feature, "checkout-v2")
+Salopulse.flush(timeout: 5)
+Salopulse.close
+```
+
+## Konfigürasyon
+
+| Seçenek            | Varsayılan | Açıklama                                       |
+|--------------------|------------|------------------------------------------------|
+| `dsn`              | —          | **Zorunlu.** `https://api_key@host` formatı    |
+| `release`          | `nil`      | Sürüm etiketi (genelde git SHA)                |
+| `environment`      | `nil`      | `production` / `staging` / ...                 |
+| `sample_rate`      | `1.0`      | 0..1 arası örnekleme oranı                     |
+| `flush_interval`   | `5` sn     | Background flush periyodu                      |
+| `flush_batch_size` | `100`      | Tek POST'ta gönderilen event sayısı            |
+| `n1_threshold`     | `10`       | Aynı fingerprint kaç defadan sonra N+1 sayılır |
+| `max_buffer_size`  | `10_000`   | Buffer üst sınırı; aşılırsa silent drop        |
+| `before_send`      | `nil`      | `->(event) { event }`; `nil` dönerse atılır    |
+| `logger`           | stdout     | SDK iç logları için                            |
+| `enabled`          | `true`     | `false` → SDK tamamen no-op                    |
+
+## Gizlilik
+
+SDK aşağıdaki alanları otomatik maskeler (`[FILTERED]`):
+
+- `password`, `password_confirmation`, `token`, `api_key`, `secret`
+- `access_token`, `refresh_token`, `authorization`, `cookie`
+- `credit_card`, `card_number`, `cvv`, `ssn`
+- Header'lar: `Authorization`, `Cookie`, `X-Api-Key`, `X-Auth-Token`
+
+## Performans
+
+- Tüm I/O background thread'inde — istek path'i bloklanmaz
+- Buffer üst sınırlı (`max_buffer_size`); patlayıp uygulamayı çökertmez
+- Transport hatalarında exponential backoff retry (max 3) — başarısızsa event düşer, uygulamaya hata sızmaz
+
+## Geliştirme
+
+```
+bundle install
+bundle exec rspec
+```
+
+## Lisans
+
+MIT

data/lib/salopulse/buffer.rb

@@ -0,0 +1,56 @@
+require "thread"
+
+module Salopulse
+  class Buffer
+    DEFAULT_MAX_SIZE = 10_000
+
+    def initialize(max_size: DEFAULT_MAX_SIZE)
+      @queue = Queue.new
+      @max_size = max_size
+      @mutex = Mutex.new
+      @dropped = 0
+    end
+
+    def push(event)
+      if @queue.size >= @max_size
+        @mutex.synchronize { @dropped += 1 }
+        return false
+      end
+      @queue.push(event)
+      true
+    end
+
+    def push_many(events)
+      events.each { |e| push(e) }
+    end
+
+    def drain(max: 100)
+      events = []
+      max.times do
+        break if @queue.empty?
+        begin
+          events << @queue.pop(true)
+        rescue ThreadError
+          break
+        end
+      end
+      events
+    end
+
+    def size
+      @queue.size
+    end
+
+    def empty?
+      @queue.empty?
+    end
+
+    def dropped_count
+      @mutex.synchronize { @dropped }
+    end
+
+    def reset_dropped!
+      @mutex.synchronize { @dropped = 0 }
+    end
+  end
+end

data/lib/salopulse/client.rb

@@ -1,52 +1,251 @@
-# frozen_string_literal: true
+require "time"
+require "singleton"
+require_relative "version"
+require_relative "configuration"
+require_relative "dsn"
+require_relative "buffer"
+require_relative "transport"
+require_relative "flusher"
+require_relative "sanitizer"
+require_relative "local_fingerprint"
+require_relative "request_context"
 
-require 'net/http'
-require 'uri'
-require 'json'
-
-module SaloPulse
+module Salopulse
   class Client
-    class << self
-      def send_event(payload)
-        config = SaloPulse.config
+    include Singleton
+
+    attr_reader :configuration, :buffer, :transport, :flusher, :dsn
 
-        return unless config.valid?
+    def initialize
+      @initialized = false
+      @mutex = Mutex.new
+    end
 
-        uri = URI.parse(config.endpoint)
+    def init(options = {})
+      @mutex.synchronize do
+        return self if @initialized
 
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl      = uri.scheme == 'https'
-        http.read_timeout = config.timeout
-        http.open_timeout = config.timeout
+        @configuration = Configuration.new
+        options.each { |k, v| @configuration.public_send("#{k}=", v) if @configuration.respond_to?("#{k}=") }
 
-        request = Net::HTTP::Post.new(uri.request_uri)
-        request['Content-Type'] = 'application/json'
-        request['Accept']       = 'application/json'
+        return self unless @configuration.enabled
 
-        body = payload.merge(
-          api_key: config.api_key,
-          environment: config.environment
+        @dsn = DSN.new(@configuration.dsn)
+        @buffer = Buffer.new(max_size: @configuration.max_buffer_size)
+        @transport = Transport.new(
+          dsn: @dsn,
+          sdk_version: Salopulse::VERSION,
+          logger: @configuration.logger
+        )
+        @flusher = Flusher.new(
+          buffer: @buffer,
+          transport: @transport,
+          interval: @configuration.flush_interval,
+          batch_size: @configuration.flush_batch_size,
+          logger: @configuration.logger
         )
+        @flusher.start
+
+        install_at_exit_hook
+
+        @initialized = true
+        self
+      end
+    end
+
+    def initialized?
+      @initialized
+    end
+
+    def uninitialized?
+      !@initialized
+    end
+
+    def disabled?
+      !@initialized || !@configuration&.enabled
+    end
 
-        request.body = JSON.generate(body)
+    # --- Capture API ---------------------------------------------------------
 
-        http.request(request)
-      rescue StandardError => e
-        log_error(e)
-        nil
+    def capture_sql(query:, duration_ms:, rows_returned: nil)
+      return if disabled?
+      return if RequestContext.suppressed?
+      return unless sample?
+
+      ctx = RequestContext.current
+      fingerprint = LocalFingerprint.for(query)
+
+      event = build_event(
+        type: "sql",
+        data: {
+          "query" => query,
+          "duration_ms" => duration_ms.to_i,
+          "endpoint" => ctx&.dig(:endpoint),
+          "http_method" => ctx&.dig(:http_method),
+          "rows_returned" => rows_returned,
+          "n1_detected" => false
+        }.compact,
+        ctx: ctx,
+        extra_envelope: { "database_dialect" => detect_dialect }
+      )
+
+      if ctx
+        RequestContext.record_sql_event(event, fingerprint)
+      else
+        enqueue(event)
       end
+    end
+
+    def capture_exception(error, user_context: nil, environment_data: nil)
+      return if disabled?
+      return unless sample?
+
+      ctx = RequestContext.current
+      data = {
+        "error_class" => error.class.name,
+        "message" => error.message.to_s,
+        "stack_trace" => Array(error.backtrace).join("\n"),
+        "endpoint" => ctx&.dig(:endpoint),
+        "http_method" => ctx&.dig(:http_method)
+      }
+      user = user_context || ctx&.dig(:user)
+      data["user_context"] = Sanitizer.scrub_hash(user) if user
+      data["environment_data"] = Sanitizer.scrub_hash(environment_data) if environment_data
+
+      enqueue(build_event(type: "error", data: data.compact, ctx: ctx))
+    end
+
+    def capture_message(message, level: :info)
+      return if disabled?
+      return unless sample?
+
+      ctx = RequestContext.current
+      data = {
+        "error_class" => "Salopulse::Message",
+        "message" => message.to_s,
+        "stack_trace" => "",
+        "endpoint" => ctx&.dig(:endpoint),
+        "http_method" => ctx&.dig(:http_method),
+        "level" => level.to_s
+      }.compact
+      enqueue(build_event(type: "error", data: data, ctx: ctx))
+    end
+
+    def capture_performance(endpoint:, http_method:, duration_ms:, status_code:, cpu_usage: nil, memory_usage: nil)
+      return if disabled?
+      return unless sample?
+
+      ctx = RequestContext.current
+      data = {
+        "endpoint" => endpoint,
+        "http_method" => http_method,
+        "duration_ms" => duration_ms.to_i,
+        "status_code" => status_code.to_i
+      }
+      data["cpu_usage"] = cpu_usage if cpu_usage
+      data["memory_usage"] = memory_usage if memory_usage
+
+      enqueue(build_event(type: "performance", data: data, ctx: ctx))
+    end
+
+    # --- Request scope -------------------------------------------------------
 
-      private
+    def flush_request_scope_events
+      ctx = RequestContext.current
+      return unless ctx
 
-      def log_error(error)
-        message = "[SaloPulse] Failed to send event: #{error.class}: #{error.message}"
+      threshold = @configuration.n1_threshold
+      counts = ctx[:sql_fingerprint_counts]
 
-        if defined?(Rails)
-          Rails.logger.debug(message)
-        else
-          warn(message)
+      ctx[:sql_events].each do |event, fingerprint|
+        if counts[fingerprint] >= threshold
+          event[:data]["n1_detected"] = true
         end
+        enqueue(event)
+      end
+    end
+
+    # --- Context helpers -----------------------------------------------------
+
+    def set_user(attrs)
+      RequestContext.set_user(attrs)
+    end
+
+    def set_tag(key, value)
+      RequestContext.set_tag(key, value)
+    end
+
+    # --- Lifecycle -----------------------------------------------------------
+
+    def flush(timeout: 5)
+      return 0 if disabled?
+      @flusher.flush_all(timeout: timeout)
+    end
+
+    def close
+      return unless @initialized
+      @flusher&.stop(timeout: 5)
+      @initialized = false
+    end
+
+    # Used by tests to wipe singleton state.
+    def reset!
+      close if @initialized
+      @configuration = nil
+      @buffer = nil
+      @transport = nil
+      @flusher = nil
+      @dsn = nil
+      @initialized = false
+    end
+
+    private
+
+    def enqueue(event)
+      return false unless @buffer
+      if @configuration.before_send
+        event = @configuration.before_send.call(event)
+        return false if event.nil?
+      end
+      @buffer.push(event)
+    end
+
+    def build_event(type:, data:, ctx:, extra_envelope: {})
+      envelope = {
+        "request_id" => ctx&.dig(:request_id),
+        "release" => @configuration.release,
+        "sdk" => { "version" => Salopulse::VERSION, "platform" => "ruby" },
+        "timestamp" => Time.now.utc.iso8601(3)
+      }.merge(extra_envelope).compact
+
+      { type: type, data: data, envelope: envelope }
+    end
+
+    def sample?
+      rate = @configuration.sample_rate.to_f
+      return true if rate >= 1.0
+      return false if rate <= 0.0
+      rand < rate
+    end
+
+    def detect_dialect
+      return "unknown" unless defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+      adapter = ActiveRecord::Base.connection.adapter_name.to_s.downcase
+      case adapter
+      when /postgres/ then "postgres"
+      when /mysql/    then "mysql"
+      when /sqlite/   then "sqlite"
+      when /sqlserver|mssql/ then "mssql"
+      else "unknown"
       end
+    rescue StandardError
+      "unknown"
+    end
+
+    def install_at_exit_hook
+      return if @at_exit_installed
+      @at_exit_installed = true
+      at_exit { close rescue nil }
     end
   end
 end

data/lib/salopulse/configuration.rb

@@ -1,19 +1,22 @@
-# frozen_string_literal: true
+require "logger"
 
-module SaloPulse
+module Salopulse
   class Configuration
-    attr_accessor :api_key, :environment, :endpoint, :timeout, :enabled
+    attr_accessor :dsn, :release, :environment, :sample_rate,
+                  :flush_interval, :flush_batch_size, :n1_threshold,
+                  :before_send, :logger, :enabled, :max_buffer_size
 
     def initialize
-      @api_key      = ENV['SALO_PULSE_API_KEY']
-      @environment  = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-      @endpoint     = ENV['SALO_PULSE_ENDPOINT'] || 'https://api.salopulse.com/v1/ingest'
-      @timeout      = 1.0
-      @enabled      = true
-    end
-
-    def valid?
-      @enabled && @api_key && !@api_key.strip.empty?
+      @release = nil
+      @environment = nil
+      @sample_rate = 1.0
+      @flush_interval = 5
+      @flush_batch_size = 100
+      @n1_threshold = 10
+      @before_send = nil
+      @logger = Logger.new($stdout, level: Logger::WARN)
+      @enabled = true
+      @max_buffer_size = 10_000
     end
   end
 end

data/lib/salopulse/dsn.rb

@@ -0,0 +1,28 @@
+require "uri"
+require_relative "error/invalid_dsn"
+
+module Salopulse
+  class DSN
+    attr_reader :api_key, :ingest_url, :host
+
+    def initialize(dsn_string)
+      raise Salopulse::Error::InvalidDSN, "DSN boş" if dsn_string.nil? || dsn_string.to_s.empty?
+
+      uri =
+        begin
+          URI.parse(dsn_string)
+        rescue URI::InvalidURIError
+          raise Salopulse::Error::InvalidDSN, "geçersiz URL"
+        end
+
+      raise Salopulse::Error::InvalidDSN, "scheme https olmalı" unless uri.scheme == "http"
+      raise Salopulse::Error::InvalidDSN, "api_key eksik" if uri.userinfo.nil? || uri.userinfo.empty?
+      raise Salopulse::Error::InvalidDSN, "host eksik" if uri.host.nil? || uri.host.empty?
+
+      @api_key = uri.userinfo
+      @host = uri.host
+      port_part = (uri.port && uri.port != 443) ? ":#{uri.port}" : ""
+      @ingest_url = "http://#{uri.host}#{port_part}/api/v1/ingest"
+    end
+  end
+end

data/lib/salopulse/error/base.rb

@@ -0,0 +1,5 @@
+module Salopulse
+  module Error
+    class Base < StandardError; end
+  end
+end

data/lib/salopulse/error/invalid_dsn.rb

@@ -0,0 +1,7 @@
+require_relative "base"
+
+module Salopulse
+  module Error
+    class InvalidDSN < Base; end
+  end
+end

data/lib/salopulse/flusher.rb

@@ -0,0 +1,67 @@
+module Salopulse
+  class Flusher
+    def initialize(buffer:, transport:, interval:, batch_size:, logger:)
+      @buffer = buffer
+      @transport = transport
+      @interval = interval
+      @batch_size = batch_size
+      @logger = logger
+      @stop = false
+      @thread = nil
+    end
+
+    def start
+      return if @thread&.alive?
+      @stop = false
+      @thread = Thread.new do
+        Thread.current.name = "salopulse-flusher" if Thread.current.respond_to?(:name=)
+        loop do
+          break if @stop
+          begin
+            flush_once
+          rescue StandardError => e
+            @logger.error("[Salopulse] flusher error: #{e.class}: #{e.message}")
+          end
+          sleep_with_interrupt(@interval)
+        end
+      end
+    end
+
+    def flush_once
+      events = @buffer.drain(max: @batch_size)
+      return 0 if events.empty?
+      @transport.send_batch(events)
+      events.size
+    end
+
+    def flush_all(timeout: 5)
+      deadline = monotonic_now + timeout
+      total = 0
+      while !@buffer.empty? && monotonic_now < deadline
+        total += flush_once
+      end
+      total
+    end
+
+    def stop(timeout: 5)
+      @stop = true
+      flush_all(timeout: timeout)
+      @thread&.join(timeout)
+    end
+
+    private
+
+    def sleep_with_interrupt(seconds)
+      slept = 0.0
+      step = 0.2
+      while slept < seconds && !@stop
+        sleep step
+        slept += step
+      end
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/salopulse/instrumentation/active_record_subscriber.rb

@@ -0,0 +1,37 @@
+module Salopulse
+  module Instrumentation
+    class ActiveRecordSubscriber
+      INTERNAL_NAMES = %w[SCHEMA TRANSACTION].freeze
+
+      def self.subscribe(client)
+        require "active_support/notifications"
+        @subscriber ||= ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          next if internal?(event)
+          next if Salopulse::RequestContext.suppressed?
+
+          client.capture_sql(
+            query: event.payload[:sql],
+            duration_ms: event.duration,
+            rows_returned: event.payload[:row_count]
+          )
+        end
+      end
+
+      def self.unsubscribe
+        return unless @subscriber
+        require "active_support/notifications"
+        ActiveSupport::Notifications.unsubscribe(@subscriber)
+        @subscriber = nil
+      end
+
+      def self.internal?(event)
+        name = event.payload[:name].to_s
+        return true if INTERNAL_NAMES.include?(name)
+        return true if event.payload[:cached]
+        sql = event.payload[:sql].to_s
+        sql.start_with?("SHOW ", "EXPLAIN ", "PRAGMA ")
+      end
+    end
+  end
+end

data/lib/salopulse/instrumentation/rack_middleware.rb

@@ -0,0 +1,69 @@
+require_relative "../request_context"
+require_relative "../sanitizer"
+
+module Salopulse
+  module Instrumentation
+    class RackMiddleware
+      def initialize(app, client = Salopulse::Client.instance)
+        @app = app
+        @client = client
+      end
+
+      def call(env)
+        return @app.call(env) if @client.disabled?
+
+        endpoint = derive_endpoint(env)
+        http_method = env["REQUEST_METHOD"]
+        Salopulse::RequestContext.start(endpoint: endpoint, http_method: http_method)
+
+        status = 500
+        begin
+          status, headers, body = @app.call(env)
+          [status, headers, body]
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          @client.capture_exception(e, environment_data: env_snapshot(env))
+          raise
+        ensure
+          begin
+            @client.capture_performance(
+              endpoint: endpoint,
+              http_method: http_method,
+              duration_ms: Salopulse::RequestContext.elapsed_ms,
+              status_code: status
+            )
+            @client.flush_request_scope_events
+          rescue StandardError
+            # never let SDK errors propagate
+          end
+          Salopulse::RequestContext.clear
+        end
+      end
+
+      private
+
+      def derive_endpoint(env)
+        if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+          begin
+            route = Rails.application.routes.recognize_path(env["PATH_INFO"], method: env["REQUEST_METHOD"])
+            return "#{route[:controller]}##{route[:action]}" if route
+          rescue StandardError
+          end
+        end
+        env["PATH_INFO"]
+      end
+
+      def env_snapshot(env)
+        params = env["action_dispatch.request.parameters"] || env["rack.request.form_hash"] || {}
+        headers = env.each_with_object({}) do |(k, v), acc|
+          next unless k.is_a?(String) && k.start_with?("HTTP_")
+          acc[k.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-")] = v
+        end
+        {
+          "ip" => env["REMOTE_ADDR"],
+          "params" => Salopulse::Sanitizer.scrub_hash(params),
+          "headers" => Salopulse::Sanitizer.scrub_headers(headers)
+        }
+      end
+    end
+  end
+end

data/lib/salopulse/local_fingerprint.rb

@@ -0,0 +1,15 @@
+module Salopulse
+  module LocalFingerprint
+    module_function
+
+    def for(sql)
+      sql.to_s
+        .downcase
+        .gsub(/'[^']*'/, "?")
+        .gsub(/\b\d+(\.\d+)?\b/, "?")
+        .gsub(/\bin\s*\([^)]+\)/, "in (?)")
+        .gsub(/\s+/, " ")
+        .strip
+    end
+  end
+end

data/lib/salopulse/railtie.rb

@@ -0,0 +1,20 @@
+module Salopulse
+  class Railtie < ::Rails::Railtie
+    initializer "salopulse.middleware" do |app|
+      app.middleware.use(Salopulse::Instrumentation::RackMiddleware)
+    end
+
+    initializer "salopulse.active_record" do
+      ActiveSupport.on_load(:active_record) do
+        Salopulse::Instrumentation::ActiveRecordSubscriber.subscribe(Salopulse::Client.instance)
+      end
+    end
+
+    config.after_initialize do
+      client = Salopulse::Client.instance
+      if client.uninitialized? && ENV["SALOPULSE_DSN"]
+        Salopulse.init(dsn: ENV["SALOPULSE_DSN"], release: ENV["GIT_SHA"], environment: defined?(Rails) ? Rails.env : nil)
+      end
+    end
+  end
+end

data/lib/salopulse/request_context.rb

@@ -0,0 +1,76 @@
+require "securerandom"
+
+module Salopulse
+  module RequestContext
+    KEY = :salopulse_request_context
+    SUPPRESS_KEY = :salopulse_suppressed
+
+    module_function
+
+    def start(endpoint:, http_method:)
+      Thread.current[KEY] = {
+        request_id: SecureRandom.uuid,
+        endpoint: endpoint,
+        http_method: http_method,
+        sql_events: [],
+        sql_fingerprint_counts: Hash.new(0),
+        started_at: monotonic_now,
+        user: nil,
+        tags: {},
+        suppressed: false
+      }
+    end
+
+    def current
+      Thread.current[KEY]
+    end
+
+    def active?
+      !current.nil?
+    end
+
+    def clear
+      Thread.current[KEY] = nil
+    end
+
+    def set_user(attrs)
+      current[:user] = attrs if current
+    end
+
+    def set_tag(key, value)
+      current[:tags][key] = value if current
+    end
+
+    def record_sql_event(event, fingerprint)
+      ctx = current
+      return false unless ctx
+      ctx[:sql_events] << [event, fingerprint]
+      ctx[:sql_fingerprint_counts][fingerprint] += 1
+      true
+    end
+
+    def elapsed_ms
+      return 0 unless current
+      ((monotonic_now - current[:started_at]) * 1000).to_i
+    end
+
+    def suppressed?
+      Thread.current[SUPPRESS_KEY] == true
+    end
+
+    def with_suppression
+      previous_ctx = Thread.current[KEY]
+      previous_suppress = Thread.current[SUPPRESS_KEY]
+      Thread.current[KEY] = nil
+      Thread.current[SUPPRESS_KEY] = true
+      yield
+    ensure
+      Thread.current[KEY] = previous_ctx
+      Thread.current[SUPPRESS_KEY] = previous_suppress
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/salopulse/sanitizer.rb

@@ -0,0 +1,41 @@
+module Salopulse
+  module Sanitizer
+    SENSITIVE_KEYS = %w[
+      password password_confirmation token api_key secret
+      access_token refresh_token authorization cookie
+      credit_card card_number cvv ssn
+    ].freeze
+
+    SENSITIVE_HEADERS = %w[
+      authorization cookie x-api-key x-auth-token
+    ].freeze
+
+    FILTERED = "[FILTERED]".freeze
+
+    module_function
+
+    def scrub_hash(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(k, v), acc|
+          acc[k] = sensitive_key?(k) ? FILTERED : scrub_hash(v)
+        end
+      when Array
+        value.map { |v| scrub_hash(v) }
+      else
+        value
+      end
+    end
+
+    def scrub_headers(headers)
+      return {} unless headers.respond_to?(:each_pair) || headers.is_a?(Hash)
+      headers.to_h.each_with_object({}) do |(k, v), acc|
+        acc[k] = SENSITIVE_HEADERS.include?(k.to_s.downcase) ? FILTERED : v
+      end
+    end
+
+    def sensitive_key?(key)
+      SENSITIVE_KEYS.include?(key.to_s.downcase)
+    end
+  end
+end

data/lib/salopulse/transport.rb

@@ -0,0 +1,73 @@
+require "net/http"
+require "json"
+require "uri"
+require_relative "request_context"
+
+module Salopulse
+  class Transport
+    MAX_RETRIES = 3
+    BACKOFF_BASE = 0.5
+
+    Response = Struct.new(:code, :body, keyword_init: true)
+
+    def initialize(dsn:, sdk_version:, logger:, open_timeout: 5, read_timeout: 10)
+      @dsn = dsn
+      @sdk_version = sdk_version
+      @logger = logger
+      @uri = URI.parse(dsn.ingest_url)
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+    end
+
+    def send_batch(events)
+      return true if events.nil? || events.empty?
+
+      body = JSON.dump(events: events)
+
+      RequestContext.with_suppression do
+        attempt = 0
+        loop do
+          response = post(body)
+          code = response.code.to_i
+          return true if success?(code)
+          return false if non_retryable?(code)
+
+          attempt += 1
+          if attempt >= MAX_RETRIES
+            @logger.warn("[Salopulse] giving up after #{attempt} attempts, last code=#{code}")
+            return false
+          end
+          sleep(BACKOFF_BASE * (2**(attempt - 1)))
+        end
+      end
+    end
+
+    private
+
+    def post(body)
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.use_ssl = (@uri.scheme == "https")
+      http.open_timeout = @open_timeout
+      http.read_timeout = @read_timeout
+
+      request = Net::HTTP::Post.new(@uri.request_uri)
+      request["Content-Type"] = "application/json"
+      request["X-Api-Key"] = @dsn.api_key
+      request["User-Agent"] = "salopulse-ruby/#{@sdk_version}"
+      request.body = body
+
+      http.request(request)
+    rescue StandardError => e
+      @logger.warn("[Salopulse] transport error: #{e.class}: #{e.message}")
+      Response.new(code: "0", body: nil)
+    end
+
+    def success?(code)
+      code == 202
+    end
+
+    def non_retryable?(code)
+      code >= 400 && code < 500 && code != 429
+    end
+  end
+end

data/lib/salopulse/version.rb

@@ -0,0 +1,3 @@
+module Salopulse
+  VERSION = "0.2.1".freeze
+end

data/lib/salopulse.rb

@@ -1,18 +1,56 @@
-# frozen_string_literal: true
+require_relative "salopulse/version"
+require_relative "salopulse/error/base"
+require_relative "salopulse/error/invalid_dsn"
+require_relative "salopulse/configuration"
+require_relative "salopulse/dsn"
+require_relative "salopulse/buffer"
+require_relative "salopulse/sanitizer"
+require_relative "salopulse/local_fingerprint"
+require_relative "salopulse/request_context"
+require_relative "salopulse/transport"
+require_relative "salopulse/flusher"
+require_relative "salopulse/client"
+require_relative "salopulse/instrumentation/active_record_subscriber"
+require_relative "salopulse/instrumentation/rack_middleware"
 
-require "salopulse/version"
-require "salopulse/configuration"
-require "salopulse/client"
-require "salopulse/middleware"
-
-module SaloPulse
+module Salopulse
   class << self
-    def configure
-      yield config
+    def init(**options)
+      Client.instance.init(options)
+    end
+
+    def capture_exception(error, **opts)
+      Client.instance.capture_exception(error, **opts)
+    end
+
+    def capture_message(message, level: :info)
+      Client.instance.capture_message(message, level: level)
+    end
+
+    def flush(timeout: 5)
+      Client.instance.flush(timeout: timeout)
+    end
+
+    def close
+      Client.instance.close
+    end
+
+    def set_user(attrs)
+      Client.instance.set_user(attrs)
+    end
+
+    def set_tag(key, value)
+      Client.instance.set_tag(key, value)
+    end
+
+    def disabled?
+      Client.instance.disabled?
     end
 
-    def config
-      @config ||= Configuration.new
+    def configuration
+      Client.instance.configuration
     end
   end
 end
+
+require_relative "salopulse/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: salopulse
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Salih İmran Büker
@@ -10,52 +10,98 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: json
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+        version: '3.12'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+- !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: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: net-http
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+        version: '7.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-description: SaloPulse Ruby SDK provides automatic request tracking, performance measurement,
-  and real-time analytics integration for Rails apps. It captures HTTP traffic and
-  sends metrics to the SaloPulse Observability Platform.
+        version: '7.0'
+description: Automatic SQL, error, and HTTP performance telemetry for Ruby applications.
+  Captures ActiveRecord queries, exceptions, and Rack request performance with zero-config
+  setup for Rails.
 email:
-- info@salopulse.com
+- salihimranbuker44@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/salopulse.rb
+- lib/salopulse/buffer.rb
 - lib/salopulse/client.rb
 - lib/salopulse/configuration.rb
-- lib/salopulse/middleware.rb
-homepage: https://github.com/mersies/salopulse-sdk-ruby
+- lib/salopulse/dsn.rb
+- lib/salopulse/error/base.rb
+- lib/salopulse/error/invalid_dsn.rb
+- lib/salopulse/flusher.rb
+- lib/salopulse/instrumentation/active_record_subscriber.rb
+- lib/salopulse/instrumentation/rack_middleware.rb
+- lib/salopulse/local_fingerprint.rb
+- lib/salopulse/railtie.rb
+- lib/salopulse/request_context.rb
+- lib/salopulse/sanitizer.rb
+- lib/salopulse/transport.rb
+- lib/salopulse/version.rb
+homepage: https://github.com/mersieS/salopulse-ruby-sdk
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/mersieS/salopulse-ruby-sdk
+  source_code_uri: https://github.com/mersieS/salopulse-ruby-sdk
+  changelog_uri: https://github.com/mersieS/salopulse-ruby-sdk/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/mersieS/salopulse-ruby-sdk/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -63,7 +109,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -72,6 +118,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
-summary: SaloPulse Ruby SDK – Lightweight monitoring and request analytics for Rails
-  applications.
+summary: Ruby SDK for Salopulse APM platform
 test_files: []

data/lib/salopulse/middleware.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack'
-require 'time'
-
-module SaloPulse
-  class Middleware
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      start_monotonic = monotonic_time
-
-      status, headers, body = @app.call(env)
-
-      duration_ms = ((monotonic_time - start_monotonic) * 1000.0).round(2)
-
-      begin
-        event = build_event(env, status, duration_ms)
-        SaloPulse::Client.send_event(event) if event
-      rescue StandardError => e
-        log_middleware_error(e)
-      end
-
-      [status, headers, body]
-    end
-
-    private
-
-    def monotonic_time
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-
-    def build_event(env, status, duration_ms)
-      req = Rack::Request.new(env)
-
-      {
-        path: req.path,
-        method: req.request_method,
-        status: status,
-        duration_ms: duration_ms,
-        ip: extract_ip(env, req),
-        user_agent: env['HTTP_USER_AGENT'],
-        occurred_at: Time.now.utc.iso8601
-      }
-    end
-
-    def extract_ip(env, req)
-      if env['action_dispatch.remote_ip']
-        env['action_dispatch.remote_ip'].to_s
-      elsif req.respond_to?(:ip)
-        req.ip
-      else
-        env['REMOTE_ADDR']
-      end
-    end
-
-    def log_middleware_error(error)
-      message = "[SaloPulse] Middleware error: #{error.class}: #{error.message}"
-
-      if defined?(Rails)
-        Rails.logger.debug(message)
-      else
-        warn(message)
-      end
-    end
-  end
-end