lescopr 0.1.0

data/lib/lescopr/core/log_queue.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lescopr
+  module Core
+    # Thread-safe in-memory log queue with automatic batching.
+    class LogQueue
+      attr_reader :size
+
+      def initialize(max_size: 1000)
+        @queue    = []
+        @mutex    = Mutex.new
+        @max_size = max_size
+      end
+
+      # @param entry [Hash]
+      def push(entry)
+        @mutex.synchronize do
+          @queue.shift if @queue.size >= @max_size  # drop oldest if full
+          @queue << entry
+        end
+      end
+
+      # Drain up to `batch_size` entries atomically.
+      # @param batch_size [Integer]
+      # @return [Array<Hash>]
+      def drain(batch_size = 50)
+        @mutex.synchronize do
+          @queue.shift(batch_size)
+        end
+      end
+
+      def size
+        @mutex.synchronize { @queue.size }
+      end
+
+      def empty?
+        @mutex.synchronize { @queue.empty? }
+      end
+    end
+  end
+end
+

data/lib/lescopr/filesystem/config_manager.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lescopr
+  module Filesystem
+    CONFIG_FILE = ".lescopr.json"
+
+    # Thread-safe reader/writer for .lescopr.json
+    class ConfigManager
+      def initialize(path: nil)
+        @path  = path || File.join(Dir.pwd, CONFIG_FILE)
+        @mutex = Mutex.new
+      end
+
+      # @return [Hash, nil]
+      def load
+        @mutex.synchronize do
+          return nil unless File.exist?(@path)
+
+          JSON.parse(File.read(@path), symbolize_names: true)
+        rescue JSON::ParserError, Errno::ENOENT
+          nil
+        end
+      end
+
+      # @param data [Hash]
+      def save(data)
+        @mutex.synchronize do
+          File.write(@path, JSON.pretty_generate(data))
+        end
+      end
+
+      def exists? = File.exist?(@path)
+
+      def delete!
+        @mutex.synchronize { File.delete(@path) if File.exist?(@path) }
+      end
+    end
+  end
+end
+

data/lib/lescopr/filesystem/project_analyzer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Lescopr
+  module Filesystem
+    # Analyses the project directory and detects framework / stack.
+    class ProjectAnalyzer
+      FRAMEWORK_SIGNATURES = {
+        "rails"     => %w[config/application.rb app/controllers config/routes.rb Gemfile],
+        "sinatra"   => %w[config.ru],
+        "rack"      => %w[config.ru Gemfile],
+        "hanami"    => %w[config/app.rb config/environment.rb],
+        "padrino"   => %w[config/apps.rb],
+        "grape"     => %w[Gemfile],
+      }.freeze
+
+      GEMFILE_PATTERNS = {
+        "rails"   => /gem\s+['"]rails['"]/,
+        "sinatra" => /gem\s+['"]sinatra['"]/,
+        "hanami"  => /gem\s+['"]hanami['"]/,
+        "padrino" => /gem\s+['"]padrino['"]/,
+        "grape"   => /gem\s+['"]grape['"]/,
+        "rack"    => /gem\s+['"]rack['"]/,
+      }.freeze
+
+      def initialize(root: Dir.pwd)
+        @root = root
+      end
+
+      # @return [Hash] payload for POST /api/v1/sdk/verify/
+      def analyze
+        stack      = detect_stack
+        ruby_ver   = RUBY_VERSION rescue "unknown"
+        gemfile    = read_gemfile
+
+        {
+          project_name:    File.basename(@root),
+          project_path:    @root,
+          project_stack:   stack,
+          language:        "ruby",
+          language_version: ruby_ver,
+          sdk_type:        "ruby",
+          gemfile_present: File.exist?(File.join(@root, "Gemfile")),
+          dependencies:    parse_gemfile_deps(gemfile),
+          environment:     ENV.fetch("RAILS_ENV", ENV.fetch("RACK_ENV", "development"))
+        }
+      end
+
+      private
+
+      def detect_stack
+        gemfile = read_gemfile
+        detected = []
+
+        GEMFILE_PATTERNS.each do |fw, pattern|
+          detected << fw if gemfile =~ pattern
+        end
+
+        FRAMEWORK_SIGNATURES.each do |fw, files|
+          next if detected.include?(fw)
+          detected << fw if files.any? { |f| File.exist?(File.join(@root, f)) }
+        end
+
+        detected.empty? ? ["ruby"] : detected.uniq
+      end
+
+      def read_gemfile
+        path = File.join(@root, "Gemfile")
+        File.exist?(path) ? File.read(path) : ""
+      rescue StandardError
+        ""
+      end
+
+      def parse_gemfile_deps(content)
+        content.scan(/gem\s+['"]([^'"]+)['"]/).flatten.first(20)
+      end
+    end
+  end
+end
+

data/lib/lescopr/integrations/rack/middleware.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lescopr
+  module Integrations
+    module Rack
+      # Rack middleware — captures exceptions from any Rack-compatible app.
+      #
+      # @example Plain Rack (config.ru)
+      #   require "lescopr"
+      #   use Lescopr::Integrations::Rack::Middleware
+      #
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+        rescue StandardError => e
+          Lescopr.log("ERROR", "#{e.class}: #{e.message}", {
+            rack_path:   env["PATH_INFO"],
+            rack_method: env["REQUEST_METHOD"],
+            backtrace:   e.backtrace&.first(10)
+          })
+          raise
+        end
+      end
+    end
+  end
+end
+

data/lib/lescopr/integrations/rails/railtie.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lescopr
+  module Integrations
+    module Rails
+      # Railtie — auto-registers Lescopr in any Rails app.
+      #
+      # Add to config/initializers/lescopr.rb:
+      #
+      #   Lescopr.configure do |c|
+      #     c.sdk_key     = ENV["LESCOPR_SDK_KEY"]
+      #     c.api_key     = ENV["LESCOPR_API_KEY"]
+      #     c.environment = ::Rails.env
+      #   end
+      #
+      class Railtie < ::Rails::Railtie
+        config.lescopr = ActiveSupport::OrderedOptions.new
+
+        initializer "lescopr.configure", after: :load_config_initializers do |app|
+          # Pick up values set in config/initializers/lescopr.rb
+          opts = app.config.lescopr
+
+          Lescopr.configure do |c|
+            c.sdk_key     = opts[:sdk_key]     || ENV["LESCOPR_SDK_KEY"]     || c.sdk_key
+            c.api_key     = opts[:api_key]     || ENV["LESCOPR_API_KEY"]     || c.api_key
+            c.environment = opts[:environment] || ENV["LESCOPR_ENVIRONMENT"] || ::Rails.env.to_s
+            c.debug       = opts[:debug]       || (ENV["LESCOPR_DEBUG"] == "true")
+          end
+        end
+
+        initializer "lescopr.middleware" do |app|
+          app.middleware.use Lescopr::Integrations::Rack::Middleware
+        end
+
+        # Hook into ActiveSupport::Notifications to capture exceptions
+        config.after_initialize do
+          if defined?(ActiveSupport::Notifications)
+            ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
+              event     = ActiveSupport::Notifications::Event.new(*args)
+              exception = event.payload[:exception_object]
+
+              if exception
+                Lescopr.log("ERROR", "#{exception.class}: #{exception.message}", {
+                  controller: event.payload[:controller],
+                  action:     event.payload[:action],
+                  path:       event.payload[:path],
+                  format:     event.payload[:format]&.to_s,
+                  backtrace:  exception.backtrace&.first(10)
+                })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/lescopr/integrations/sinatra/extension.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lescopr
+  module Integrations
+    module Sinatra
+      # Sinatra extension — registers a helper and hooks into error handling.
+      #
+      # @example
+      #   require "sinatra"
+      #   require "lescopr"
+      #
+      #   class MyApp < Sinatra::Base
+      #     register Lescopr::Integrations::Sinatra::Extension
+      #
+      #     get "/" do
+      #       lescopr_log(:info, "Home page visited")
+      #       "Hello!"
+      #     end
+      #   end
+      #
+      module Extension
+        def self.registered(app)
+          app.use Lescopr::Integrations::Rack::Middleware
+
+          app.helpers Helpers
+
+          app.error(StandardError) do |e|
+            Lescopr.log("ERROR", "#{e.class}: #{e.message}", {
+              sinatra_path:   request.path_info,
+              sinatra_method: request.request_method,
+              backtrace:      e.backtrace&.first(10)
+            })
+            raise e
+          end
+        end
+      end
+
+      module Helpers
+        def lescopr_log(level, message, metadata = {})
+          Lescopr.log(level, message, metadata.merge(sinatra_route: request.path_info))
+        end
+      end
+    end
+  end
+end
+

data/lib/lescopr/monitoring/logger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Lescopr
+  module Monitoring
+    # Internal SDK logger — writes to .lescopr.log, never pollutes app output.
+    class Logger
+      LOG_FILE = ".lescopr.log"
+      MAX_SIZE  = 5 * 1024 * 1024 # 5 MB
+      MAX_FILES = 3
+
+      def initialize(debug: false)
+        @debug   = debug
+        @logger  = build_logger
+      end
+
+      def debug(msg) = @logger.debug(format_msg(msg)) if @debug
+      def info(msg)  = @logger.info(format_msg(msg))
+      def warn(msg)  = @logger.warn(format_msg(msg))
+      def error(msg) = @logger.error(format_msg(msg))
+      def fatal(msg) = @logger.fatal(format_msg(msg))
+
+      private
+
+      def format_msg(msg) = "[LESCOPR] #{msg}"
+
+      def build_logger
+        log_path = File.join(Dir.pwd, LOG_FILE)
+        logger = ::Logger.new(log_path, MAX_FILES, MAX_SIZE)
+        logger.level = @debug ? ::Logger::DEBUG : ::Logger::INFO
+        logger.formatter = proc do |sev, time, _prog, msg|
+          "#{time.strftime('%Y-%m-%dT%H:%M:%S')} #{sev}: #{msg}\n"
+        end
+        logger
+      rescue StandardError
+        ::Logger.new($stderr)
+      end
+    end
+  end
+end
+

data/lib/lescopr/transport/http_client.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Lescopr
+  module Transport
+    # HTTPS batch transport to api.lescopr.com
+    class HttpClient
+      BASE_URL    = "https://api.lescopr.com/api/v1"
+      TIMEOUT_SEC = 10
+      MAX_RETRIES = 3
+
+      def initialize(api_key:, sdk_key:)
+        @api_key = api_key
+        @sdk_key = sdk_key
+      end
+
+      # Register / verify the project with the API.
+      # @param payload [Hash]
+      # @return [Hash, nil]
+      def verify_project(payload)
+        post("/sdk/verify/", payload)
+      end
+
+      # Send a batch of log entries.
+      # @param logs [Array<Hash>]
+      # @return [Boolean]
+      def send_logs(logs)
+        return true if logs.empty?
+
+        result = post("/sdk/logs/", { logs: logs })
+        !result.nil?
+      end
+
+      # Send a single heartbeat.
+      def send_heartbeat(sdk_id)
+        post("/sdk/heartbeat/", { sdk_id: sdk_id })
+      end
+
+      private
+
+      def post(path, body)
+        uri  = URI("#{BASE_URL}#{path}")
+        http = build_http(uri)
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"]  = "application/json"
+        request["X-API-Key"]     = @api_key.to_s
+        request["X-SDK-Key"]     = @sdk_key.to_s
+        request["User-Agent"]    = "lescopr-ruby/#{Lescopr::VERSION}"
+        request.body = body.to_json
+
+        retries = 0
+        begin
+          response = http.request(request)
+          return JSON.parse(response.body, symbolize_names: true) if response.is_a?(Net::HTTPSuccess)
+
+          nil
+        rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, SocketError => e
+          retries += 1
+          retry if retries < MAX_RETRIES
+          nil
+        end
+      end
+
+      def build_http(uri)
+        http              = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = uri.scheme == "https"
+        http.open_timeout = TIMEOUT_SEC
+        http.read_timeout = TIMEOUT_SEC
+        http
+      end
+    end
+  end
+end
+

data/lib/lescopr/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Lescopr
+  VERSION = "0.1.0"
+end
+

data/lib/lescopr.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require "logger"
+require "singleton"
+
+require_relative "lescopr/version"
+require_relative "lescopr/monitoring/logger"
+require_relative "lescopr/filesystem/config_manager"
+require_relative "lescopr/filesystem/project_analyzer"
+require_relative "lescopr/transport/http_client"
+require_relative "lescopr/core/client"
+require_relative "lescopr/core/log_queue"
+require_relative "lescopr/core/daemon_runner"
+
+# Framework integrations — loaded lazily based on detected environment
+require_relative "lescopr/integrations/rack/middleware"
+require_relative "lescopr/integrations/sinatra/extension"
+
+# Rails Railtie is auto-loaded when Rails is present
+if defined?(Rails)
+  require_relative "lescopr/integrations/rails/railtie"
+end
+
+##
+# Lescopr — zero-configuration Ruby monitoring SDK.
+#
+# @example Plain Ruby / Rack
+#   require "lescopr"
+#   Lescopr.init!(sdk_key: "lsk_xxx", api_key: "lak_xxx")
+#
+# @example Rails (auto-init via Railtie)
+#   # config/initializers/lescopr.rb
+#   Lescopr.configure do |c|
+#     c.sdk_key     = ENV["LESCOPR_SDK_KEY"]
+#     c.api_key     = ENV["LESCOPR_API_KEY"]
+#     c.environment = ENV.fetch("LESCOPR_ENVIRONMENT", "production")
+#   end
+#
+module Lescopr
+  BASE_URL = "https://api.lescopr.com/api/v1"
+
+  class << self
+    # @return [Lescopr::Core::Client] the active SDK client instance
+    attr_reader :client
+
+    # Configure the SDK via a block.
+    #
+    # @yieldparam config [Lescopr::Configuration]
+    def configure
+      yield(configuration)
+      @client = Core::Client.new(configuration)
+      @client.setup_auto_logging!
+      @client
+    end
+
+    # Shorthand initialiser — accepts a hash or keyword args.
+    #
+    # @param opts [Hash]
+    # @option opts [String] :sdk_key  SDK key (lsk_xxx)
+    # @option opts [String] :api_key  API key (lak_xxx)
+    # @option opts [String] :environment  "development" or "production"
+    def init!(opts = {})
+      configuration.sdk_key     = opts[:sdk_key]     if opts[:sdk_key]
+      configuration.api_key     = opts[:api_key]     if opts[:api_key]
+      configuration.environment = opts[:environment] if opts[:environment]
+      configure { |_c| } # trigger setup
+    end
+
+    # Send a log entry manually.
+    #
+    # @param level  [String, Symbol] log level (debug/info/warn/error/fatal)
+    # @param message [String]
+    # @param metadata [Hash] extra context
+    def log(level, message, metadata = {})
+      return unless client&.ready?
+
+      client.send_log(level.to_s.upcase, message, metadata)
+    end
+
+    # @return [Lescopr::Configuration]
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Reset the SDK (useful in tests).
+    def reset!
+      @client&.shutdown!
+      @client        = nil
+      @configuration = nil
+    end
+  end
+
+  # ─── Configuration ────────────────────────────────────────────────────────
+  class Configuration
+    attr_accessor :sdk_key, :api_key, :environment, :debug, :batch_size, :flush_interval
+
+    def initialize
+      @sdk_key        = ENV["LESCOPR_SDK_KEY"]
+      @api_key        = ENV["LESCOPR_API_KEY"]
+      @environment    = ENV.fetch("LESCOPR_ENVIRONMENT", "development")
+      @debug          = ENV["LESCOPR_DEBUG"] == "true"
+      @batch_size     = 50
+      @flush_interval = 5 # seconds
+    end
+  end
+end
+

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: lescopr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SonnaLab
+bindir: exe
+cert_chain: []
+date: 2026-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        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: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.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'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: Lescopr automatically captures logs, errors and exceptions from any Ruby
+  project and streams them in real-time to the Lescopr dashboard. Works with Rails,
+  Sinatra, Rack and plain Ruby.
+email:
+- support@lescopr.com
+executables:
+- lescopr
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/lescopr
+- lib/lescopr.rb
+- lib/lescopr/core/client.rb
+- lib/lescopr/core/daemon_runner.rb
+- lib/lescopr/core/log_queue.rb
+- lib/lescopr/filesystem/config_manager.rb
+- lib/lescopr/filesystem/project_analyzer.rb
+- lib/lescopr/integrations/rack/middleware.rb
+- lib/lescopr/integrations/rails/railtie.rb
+- lib/lescopr/integrations/sinatra/extension.rb
+- lib/lescopr/monitoring/logger.rb
+- lib/lescopr/transport/http_client.rb
+- lib/lescopr/version.rb
+homepage: https://lescopr.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://lescopr.com
+  source_code_uri: https://github.com/Lescopr/lescopr-ruby
+  changelog_uri: https://github.com/Lescopr/lescopr-ruby/blob/main/CHANGELOG.md
+  documentation_uri: https://docs.lescopr.com
+  bug_tracker_uri: https://github.com/Lescopr/lescopr-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.3
+specification_version: 4
+summary: Zero-configuration Ruby monitoring SDK
+test_files: []