end_point_blank 0.2.0

data/lib/end_point_blank/commands/endpoint_update.rb

@@ -0,0 +1,129 @@
+#!/bin/ruby
+
+require 'excon'
+require_relative 'http'
+
+module EndPointBlank
+  module Commands
+    # Collects and sends application endpoint information to a remote registry service.
+    # Scans all Rails routes and extracts details including path, HTTP verb, API version,
+    # and deprecation status from controller versioning concerns. Sends this data along
+    # with application metadata (name, hostname, environment) to the configured endpoint_update_url
+    # for centralized endpoint tracking and documentation.
+    class EndpointUpdate
+      def initialize
+      end
+
+      def configuration
+        EndPointBlank::Configuration.instance
+      end
+
+      def auth
+        Authorization.header
+      end
+
+      def write(data)
+        EndPointBlank.logger.info "[EndPointBlank] Sending application update: " \
+          "application=#{data[:application]} environment=#{data[:environment]} " \
+          "app_version=#{data[:app_version]}"
+
+        response = Excon.post(configuration.endpoint_update_url,
+          headers: {'Authorization' => auth, 'Content-Type' => 'application/json'},
+          body: data.to_json,
+          **EndPointBlank::Commands::Http::TIMEOUT_OPTIONS
+        )
+        if response.status > 299
+          EndPointBlank.logger.error "Failed to update endpoint: #{response.status} - #{response.body}"
+        else
+          EndPointBlank.logger.info "Endpoint updated successfully: #{response.status}"
+        end
+      rescue Excon::Error => e
+        # Was `rescue Excon::Error::Socket, Excon::Error::Connection` -
+        # Excon::Error::Connection does not exist in this excon version, so
+        # that clause raised NameError instead of catching anything, and a
+        # timeout (Excon::Error::Timeout) would have crashed the caller.
+        # Rescuing Excon::Error catches every transport failure, including
+        # timeouts, without letting this fire-and-forget call ever raise.
+        EndPointBlank.logger.warn "EndPointBlank: could not reach intake to update endpoints (#{e.message})"
+      end
+
+      def self.update
+        new.update
+      end
+
+      def update
+        write(application_info)
+      end
+
+      def application_info
+        {
+          application: application_name,
+          hostname: hostname,
+          lib_version: EndPointBlank::VERSION,
+          environment: environment,
+          endpoints: ,
+          app_version: ,
+        }
+      end
+
+      private
+
+      def app_version
+        return configuration.application_version if configuration.respond_to?(:application_version) && configuration.application_version.present?
+
+        nil
+      end
+
+      def application_name
+        ::Rails.application.class.module_parent_name.underscore
+      end
+
+      def hostname
+        # Try to get hostname from various sources
+        if defined?(::Rails) && ::Rails.application.config.respond_to?(:force_ssl) && ::Rails.application.config.force_ssl
+          protocol = 'https'
+        else
+          protocol = 'http'
+        end
+
+        host = if ::Rails.application.config.respond_to?(:host)
+                 ::Rails.application.config.host
+               elsif defined?(ActionMailer) && ActionMailer::Base.default_url_options[:host]
+                 ActionMailer::Base.default_url_options[:host]
+               else
+                 'localhost'
+               end
+
+        port = ::Rails.application.config.respond_to?(:port) ? ::Rails.application.config.port : nil
+        port_suffix = port && port != 80 && port != 443 ? ":#{port}" : ""
+
+        "#{host}#{port_suffix}"
+      end
+
+      def environment
+        ::Rails.env
+      end
+
+      def endpoints
+        ::Rails.application.routes.routes.map do |route|
+          if route.defaults[:controller].nil? || route.defaults[:action].nil?
+            nil
+          else
+            controller_class = "#{route.defaults[:controller].camelize}Controller".constantize
+            versions = controller_class.respond_to?(:versions) ? controller_class.versions(route.defaults[:action].to_sym) : {}
+            {
+              path: route.path.spec.to_s.gsub(/\([^)]*\)/, ''),
+              http_method: route.verb,
+              endpoint_versions: versions,
+            }
+          end
+        end.compact.uniq.filter { |e| e[:path].present? && !(e[:path].start_with?('/rails/') || e[:path] == '/assets' || e[:endpoint_versions].empty?)}
+      end
+
+      def extract_version_from_path(path)
+        match = path.match(/\/v(\d+)\//)
+        match ? "v#{match[1]}" : nil
+      end
+    end
+  end
+end

data/lib/end_point_blank/commands/generate_access_token.rb

@@ -0,0 +1,46 @@
+#!/bin/ruby
+
+require 'excon'
+require "json"
+require_relative 'http'
+
+module EndPointBlank
+  module Commands
+    module GenerateAccessTokenMethods
+      module ClassMethods
+        def configuration
+          EndPointBlank::Configuration.instance
+        end
+
+        def token(hostname)
+          body = {hostname: hostname}
+          if configuration.token_ttl
+            body[:token_ttl] = configuration.token_ttl
+          end
+          auth = Authorization.header
+          response = Excon.post(configuration.access_token_url,
+            headers: {'Authorization' => auth, 'Content-Type' => 'application/json'},
+            body: body.to_json,
+            **EndPointBlank::Commands::Http::TIMEOUT_OPTIONS
+          )
+          EndPointBlank.logger.info "Authentication response: #{response.status} - #{response.body}"
+          parsed_body = response.body.is_a?(String) ? JSON.parse(response.body) : response.body
+          parsed_body.transform_keys(&:to_sym)
+        rescue => e
+          EndPointBlank.logger.error "Error occurred during authentication: #{e.message}\n #{e.backtrace.join("\n")}"
+          nil
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    # Generates an access token by sending a request to a remote authorization service.
+    # Returns the access token from the authorization service or nil if an error occurs.
+    class GenerateAccessToken
+      include GenerateAccessTokenMethods
+    end
+  end
+end

data/lib/end_point_blank/commands/http.rb

@@ -0,0 +1,45 @@
+require 'excon'
+
+module EndPointBlank
+  module Commands
+    module Http
+      MAX_ATTEMPTS = 3
+      RETRY_DELAY  = 0.2
+
+      # Per-attempt timeouts (seconds). Kept short because every call site in
+      # this lib is fire-and-forget telemetry: a slow/unreachable intake must
+      # never block the host application's request thread.
+      CONNECT_TIMEOUT = 3
+      READ_TIMEOUT    = 5
+
+      # Shared Excon options so the timeout values live in exactly one place.
+      # Merge this into any `Excon.post`/`Excon.new` call in the lib.
+      TIMEOUT_OPTIONS = { connect_timeout: CONNECT_TIMEOUT, read_timeout: READ_TIMEOUT }.freeze
+
+      def self.post(url, auth, body)
+        attempt = 0
+        begin
+          attempt += 1
+          Excon.post(
+            url,
+            headers: { 'Authorization' => auth, 'Content-Type' => 'application/json' },
+            body: body.to_json,
+            **TIMEOUT_OPTIONS
+          )
+        rescue Excon::Error => e
+          # Excon::Error::Timeout (raised for both connect_timeout and
+          # read_timeout) is a subclass of Excon::Error, so it is handled
+          # here the same as any other transport error: retried, then
+          # swallowed with a log line rather than raised to the caller.
+          if attempt < MAX_ATTEMPTS
+            sleep RETRY_DELAY
+            retry
+          end
+          EndPointBlank.logger.error \
+            "[EndPointBlank] HTTP POST to #{url} failed after #{MAX_ATTEMPTS} attempts: #{e.message}"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/end_point_blank/commands/route_pattern_finder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EndPointBlank
+  module Commands
+    class RoutePatternFinder
+      def self.find(request)
+        return nil unless defined?(::Rails)
+
+        matched = nil
+        ::Rails.application.routes.router.recognize(request) do |route, _params|
+          matched = route.path.spec.to_s
+          break
+        end
+        matched
+      rescue StandardError => e
+        EndPointBlank.logger.debug("Error finding route pattern: #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/end_point_blank/commands/version_finder.rb

@@ -0,0 +1,70 @@
+module EndPointBlank
+  module Commands
+    # Finds the API version from an incoming request by checking multiple sources:
+    # - Custom version finder configured in Configuration.instance.version_finder
+    # - Accept header (e.g., application/vnd.api.v1+json)
+    # - X-Api-Version header (e.g., v1)
+    # - Content-Type header (e.g., application/vnd.api.v1+json)
+    # - Query parameter 'version' (e.g., ?version=v1)
+    # - URL path segment (e.g., /v1/resource)
+    # - Controller versioning configuration (via Versioned concern)
+    # Returns the version number as a string (e.g., "1") or nil if no version is found.
+    class VersionFinder
+      def headers
+        @headers ||= ::EndPointBlank::Rack::Headers.extract
+      end
+      def find(request)
+        return Configuration.instance.version_finder.call(request) if Configuration.instance.version_finder
+
+        return version if respond_to?(:version)
+
+        # Logic to determine version from request
+        # This could involve checking headers, query parameters, etc.
+        headers["Accept"]&.match(%r{application/vnd\.\w+\.v(\d+)}) do |m|
+          return m[1]
+        end
+
+        headers["X-Api-Version"]&.match(/v(\d+)/) do |m|
+          return m[1]
+        end
+
+        headers["Content-Type"]&.match(%r{application/vnd\.\w+\.v(\d+)}) do |m|
+          return m[1]
+        end
+
+        request.params["version"]&.match(/v(\d+)/) do |m|
+          return m[1]
+        end
+
+        request.path.match(%r{/v(\d+)/}) do |m|
+          return m[1]
+        end
+
+        # Try to find version from controller versioning configuration
+        version_from_controller(request)
+      end
+
+      private
+
+      def version_from_controller(request)
+        return nil unless defined?(::Rails)
+        return nil unless request.respond_to?(:path_parameters)
+
+        controller_name = request.path_parameters[:controller]
+        action_name = request.path_parameters[:action]
+
+        return nil if controller_name.nil? || action_name.nil?
+
+        controller_class = "#{controller_name.camelize}Controller".constantize
+        return nil unless controller_class.respond_to?(:versions)
+
+        versions = controller_class.versions(action_name.to_sym)
+        return nil if versions.empty?
+
+        versions.values.flatten.first&.match(/v?(\d+)/)&.[](1)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/end_point_blank/configuration.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module EndPointBlank
+  # Singleton configuration object for the EndPointBlank client.
+  #
+  # Values may be set explicitly via {EndPointBlank.configure}. Several
+  # settings also fall back to ENDPOINTBLANK_* environment variables when
+  # not explicitly configured, in order to support Rails-free deployments.
+  class Configuration
+    include Singleton
+
+    attr_writer :client_id, :client_secret, :base_url, :log_base_url, :app_name, :env_name
+
+    attr_accessor :environment, :worker_count, :log_mode,
+                  :version_finder, :application_version, :token_ttl, :cache_ttl,
+                  :masking_rules, :mask_hook, :logger
+
+    def initialize
+      @worker_count = 4
+      @token_ttl = nil
+      @cache_ttl = 300
+      @masking_rules = []
+      @mask_hook = nil
+    end
+
+    # Returns the configured client id, falling back to the
+    # ENDPOINTBLANK_CLIENT_ID environment variable when not explicitly set.
+    def client_id
+      @client_id || ENV["ENDPOINTBLANK_CLIENT_ID"]
+    end
+
+    # Returns the configured client secret, falling back to the
+    # ENDPOINTBLANK_CLIENT_SECRET environment variable when not explicitly set.
+    def client_secret
+      @client_secret || ENV["ENDPOINTBLANK_CLIENT_SECRET"]
+    end
+
+    # Returns the configured base URL, falling back to the
+    # ENDPOINTBLANK_BASE_URL environment variable, then a built-in default.
+    def base_url
+      @base_url || ENV["ENDPOINTBLANK_BASE_URL"] || "https://in.endpointblank.com"
+    end
+
+    # Returns the configured log base URL, falling back to the
+    # ENDPOINTBLANK_LOG_BASE_URL environment variable, then a built-in default.
+    def log_base_url
+      @log_base_url || ENV["ENDPOINTBLANK_LOG_BASE_URL"] || "https://log.endpointblank.com"
+    end
+
+    def endpoint_update_url
+      "#{base_url}/api/application_updates"
+    end
+
+    def access_token_url
+      "#{base_url}/api/access_token"
+    end
+
+    def authorize_url
+      "#{base_url}/api/authorize"
+    end
+
+    def errors_url
+      "#{log_base_url}/api/application_errors"
+    end
+
+    def requests_url
+      "#{log_base_url}/api/application_requests"
+    end
+
+    def responses_url
+      "#{log_base_url}/api/application_responses"
+    end
+
+    def logs_url
+      "#{log_base_url}/api/application_logs"
+    end
+
+    # Returns the name of the application.
+    #
+    # If {#app_name=} is called, then that value is returned.
+    #
+    # Otherwise, falls back to the ENDPOINTBLANK_APP_NAME environment
+    # variable.
+    #
+    # Otherwise, if the application is a Rails application, then
+    # {::Rails.application.name} is returned.
+    #
+    # Otherwise, nil is returned.
+    def app_name
+      if @app_name
+        @app_name
+      elsif ENV["ENDPOINTBLANK_APP_NAME"]
+        ENV["ENDPOINTBLANK_APP_NAME"]
+      elsif defined?(::Rails)
+        ::Rails.application.name.underscore
+      end
+    end
+
+    # Returns the configured environment name, falling back to the
+    # ENDPOINTBLANK_ENV environment variable when not explicitly set.
+    def env_name
+      @env_name || ENV["ENDPOINTBLANK_ENV"]
+    end
+  end
+end

data/lib/end_point_blank/fast_json_truncator.rb

@@ -0,0 +1,49 @@
+require "json"
+
+class FastJsonTruncator
+  MAX_BYTES  = 10000
+  MAX_DEPTH  = 5
+  MAX_LIST   = 20
+  MAX_STRING = 200
+  MAX_KEYS   = 20
+
+  def self.truncate(data, limit = MAX_BYTES)
+    pruned = prune(data, 0)
+    json = JSON.generate(pruned)
+    ensure_limit(json, limit)
+  end
+
+  def self.prune(value, depth)
+    return "[truncated]" if depth > MAX_DEPTH
+
+    case value
+    when Hash
+      result = {}
+      value.each_with_index do |(k, v), i|
+        break if i >= MAX_KEYS
+        result[k] = prune(v, depth + 1)
+      end
+      result
+
+    when Array
+      value.first(MAX_LIST).map { |v| prune(v, depth + 1) }
+
+    when String
+      if value.bytesize > MAX_STRING
+        value.byteslice(0, MAX_STRING) + "..."
+      else
+        value
+      end
+
+    else
+      value
+    end
+  end
+
+  def self.ensure_limit(json, limit)
+    return json if json.bytesize <= limit
+
+    truncated = json.byteslice(0, limit - 20)
+    truncated + '...,"truncated":true}'
+  end
+end

data/lib/end_point_blank/log_entry.rb

@@ -0,0 +1,16 @@
+module EndPointBlank
+  class LogEntry
+    attr_accessor :message, :stacktrace, :app, :status, :headers, :body, :env, :sent_at
+
+    def initialize(message:, env: , stacktrace:, app:, status:, headers:, body:, sent_at: Time.now)
+      @message = message
+      @env = env
+      @stacktrace = stacktrace
+      @app = app
+      @status = status
+      @headers = headers
+      @body = body
+      @sent_at = sent_at
+    end
+  end
+end

data/lib/end_point_blank/loggers/logger.rb

@@ -0,0 +1,30 @@
+module EndPointBlank
+  module Loggers
+    class Logger
+
+      def self.info(message)
+      end
+
+      def self.debug(message)
+        Writers::Writer.new(:debug).write(message: message)
+      end
+
+      def self.error(message)
+        EndPointBlank.logger.error(message)
+      end
+
+      def self.warn(message)
+        EndPointBlank.logger.warn(message)
+      end
+
+      def self.fatal(message)
+        EndPointBlank.logger.fatal(message)
+      end
+
+      private
+      def self.write(message:, level: )
+        Writers::Writer.new(:info).write(message: message)
+      end
+    end
+  end
+end