api_logger 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84a8975ee0261c8d69b6d8da6d1aca8e4365abb85b6087eb21ddde88a4051dfa
+  data.tar.gz: '09f10422f744f28ec157ec0486b8e5f50753e9566432bbbabcc2068b4c028967'
+SHA512:
+  metadata.gz: 4db6070b693462f259cca685bfb1de280d1586b21e671012a8da74f35512d20f9725dde96a2d7ee3d3c7ca43de59e92b0a60709d4c50e4e522fbf7cb3e8e82fa
+  data.tar.gz: 386ae70a35aec046e20e50529b19fc56fbf7bbf01f0d2957d93c50d9641ecb1735b6fd3254a44ef293ea0fb297cd7cecb9138931925d84ee5aa781eaf1a3465c

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in api_logger.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.12'
+  gem 'webmock', '~> 3.19'
+  gem 'simplecov', '~> 0.22', require: false
+  gem 'rubocop', '~> 1.57', require: false
+  gem 'rubocop-rspec', '~> 2.25', require: false
+  gem 'rubocop-rails', '~> 2.22', require: false
+  gem 'pry', '~> 0.14'
+  gem 'pry-byebug', '~> 3.10'
+  gem 'rake', '~> 13.0'
+end

data/README.md

@@ -0,0 +1,124 @@
+# API Logger
+
+A simple gem for logging API requests and responses in Rails applications. It automatically logs outbound HTTP requests to specified hosts with zero configuration needed.
+
+## Overview
+![alt text](diagram.png "Title")
+
+## Features
+
+- **Selective Request Logging**: Logs outbound HTTP requests only to specified hosts
+- **Zero Configuration**: Works out of the box with sensible defaults
+- **Flexible Control**: Easy to enable/disable logging through configuration
+- **Comprehensive Logging**: Captures request parameters, response bodies, status codes, and errors
+- **Database Storage**: All logs are stored in your database for easy querying
+- **Rails Integration**: Seamlessly integrates with your Rails application
+- **Stack Safe**: Prevents recursive logging and stack overflow issues
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'api_logger', github: 'Superlinear-Insights/api_logger'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+$ rails generate api_logger:install
+$ rails db:migrate
+```
+
+## Configuration
+
+Configure which hosts to log by creating an initializer (`config/initializers/api_logger.rb`):
+
+```ruby
+ApiLogger.configure do |config|
+  # The database table where logs will be stored
+  config.table_name = 'api_logs'  # default
+
+  # Enable/disable all logging functionality
+  config.enabled = true  # default
+
+  # Enable/disable automatic request logging via middleware
+  config.use_middleware = true  # default
+
+  # Specify which hosts to log (empty array means log nothing)
+  config.allowed_hosts = [
+    'services.mfcentral.com',
+    'uatservices.mfcentral.com'
+  ]
+end
+```
+
+### Configuration Options
+
+- `table_name`: The name of the database table where logs will be stored
+- `enabled`: Master switch to enable/disable all logging functionality
+- `use_middleware`: Controls automatic logging of HTTP requests
+- `allowed_hosts`: Array of host strings that should be logged (empty means log nothing)
+
+
+
+## Usage
+
+### Automatic Request Logging
+
+With default configuration, any HTTP request to allowed hosts will be automatically logged:
+
+```ruby
+# This request WILL be logged
+uri = URI('https://services.mfcentral.com/api/v1/users')
+response = Net::HTTP.get_response(uri)
+
+# This request will NOT be logged
+uri = URI('https://api.other-service.com/users')
+response = Net::HTTP.get_response(uri)
+```
+
+### Accessing Logs
+
+Logs are accessible through the `ApiLog` model:
+
+```ruby
+# Get the most recent log
+ApiLog.last
+
+# Get recent logs
+ApiLog.order(created_at: :desc)
+
+# Find logs for a specific endpoint
+ApiLog.where(endpoint: '/api/v1/users')
+
+# Get failed requests (status >= 400)
+ApiLog.where('response_status >= ?', 400)
+
+# Get successful requests
+ApiLog.where('response_status < ?', 400)
+```
+
+### Log Data Structure
+
+Each log entry contains:
+- `endpoint`: The API endpoint that was called
+- `request_params`: Parameters sent with the request (stored as JSON)
+- `response_body`: The response received (stored as JSON)
+- `response_status`: HTTP status code of the response
+- `error_message`: Error message (for failed requests)
+- `created_at`: When the log was created
+- `updated_at`: When the log was last updated
+
+## Maintenance
+
+To clean up old logs, use the provided rake task:
+
+```bash
+# Clean logs older than 30 days (default)
+rails api_logger:clean
+
+# Clean logs older than N days
+DAYS=7 rails api_logger:clean
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/api_logger/configuration.rb

@@ -0,0 +1,23 @@
+module ApiLogger
+  class Configuration
+    attr_accessor :table_name, :enabled, :use_middleware, :allowed_hosts, :exclude_hosts, :exclude_routes
+
+    def initialize
+      @table_name = 'api_logs'
+      @enabled = true
+      @use_middleware = true
+      @allowed_hosts = ['services.mfcentral.com', 'uatservices.mfcentral.com']
+      # backwards compatibility, to be removed in next release.
+      @exclude_hosts = []
+      @exclude_routes = []
+    end
+
+    def should_log_route?(path, host = nil)
+      return false unless enabled && use_middleware
+      return false unless host
+
+      # Only log if host is in allowed list
+      allowed_hosts.include?(host)
+    end
+  end
+end

data/lib/api_logger/generators.rb

@@ -0,0 +1 @@
+require 'generators/api_logger/install/install_generator' 

data/lib/api_logger/middleware.rb

@@ -0,0 +1,93 @@
+module ApiLogger
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # Apply our patch only if not already applied
+      unless Net::HTTP.method_defined?(:request_with_api_logger)
+        apply_http_patch
+      end
+      
+      @app.call(env)
+    end
+    
+    private
+    
+    def apply_http_patch
+      Net::HTTP.class_eval do
+        # Only patch if we haven't already
+        unless method_defined?(:request_with_api_logger)
+          # Keep reference to the current 'request' method, which might already be patched by Sentry
+          alias_method :request_without_api_logger, :request
+          
+          # Define our wrapper method
+          def request_with_api_logger(req, body = nil, &block)
+            # Skip if we're already processing a request
+            if Thread.current[:api_logger_active]
+              return request_without_api_logger(req, body, &block)
+            end
+
+            Thread.current[:api_logger_active] = true
+            begin
+              # Call the existing chain (which might include Sentry's instrumentation)
+              response = request_without_api_logger(req, body, &block)
+              
+              # Extract the actual host from the request
+              host = extract_host(req)
+              path = req.path
+              
+              if ApiLogger.configuration.should_log_route?(path, host)
+                ApiLogger.log(
+                  endpoint: path,
+                  http_method: req.method,
+                  request_params: req.body || body,
+                  request_headers: req.each_header.to_h,
+                  response_body: response.body,
+                  response_headers: response.each_header.to_h,
+                  response_status: response.code.to_i
+                )
+              end
+              
+              response
+            rescue => e
+              # Log errors
+              host = extract_host(req)
+              path = req.path
+              
+              if ApiLogger.configuration.should_log_route?(path, host)
+                ApiLogger.log(
+                  endpoint: path,
+                  http_method: req.method,
+                  request_params: req.body || body,
+                  request_headers: req.each_header.to_h,
+                  error_message: e.message
+                )
+              end
+              
+              raise
+            ensure
+              Thread.current[:api_logger_active] = nil
+            end
+          end
+          
+          # Complete the method chain
+          alias_method :request, :request_with_api_logger
+          
+          private
+          
+          def extract_host(req)
+            # Try to get host from URI first
+            if req.uri
+              return req.uri.host
+            end
+            
+            # Fallback to host header or address
+            req['host'] || self.address
+          end
+        end
+      end
+    end
+  end
+end

data/lib/api_logger/railtie.rb

@@ -0,0 +1,42 @@
+require 'rails'
+require 'api_logger/middleware'
+
+module ApiLogger
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/api_logger_tasks.rake"
+    end
+    
+    generators do
+      require "generators/api_logger/install/install_generator"
+    end
+
+    # Define the model class when Rails initializes
+    config.before_initialize do
+      # Create ApiLog constant if it doesn't exist
+      unless Object.const_defined?('ApiLog')
+        Object.const_set('ApiLog', Class.new(ActiveRecord::Base) do
+          self.table_name = ApiLogger.configuration.table_name
+
+          # Add some useful scopes
+          scope :recent, -> { order(created_at: :desc) }
+          scope :failed, -> { where('response_status >= ?', 400) }
+          scope :successful, -> { where('response_status < ?', 400) }
+        end)
+      end
+    end
+
+    # Load middleware as early as possible
+    initializer "api_logger.configure_middleware", before: :load_config_initializers do |app|
+      if ApiLogger.configuration.enabled && ApiLogger.configuration.use_middleware
+        app.middleware.use ApiLogger::Middleware
+        
+        # Apply the patch immediately
+        unless Net::HTTP.method_defined?(:request_with_api_logger)
+          middleware = ApiLogger::Middleware.new(-> (env) { [200, {}, []] })
+          middleware.send(:apply_http_patch)
+        end
+      end
+    end
+  end
+end

data/lib/api_logger/version.rb

@@ -0,0 +1,3 @@
+module ApiLogger
+  VERSION = "0.2.0"
+end

data/lib/api_logger.rb

@@ -0,0 +1,95 @@
+require 'api_logger/version'
+require 'api_logger/configuration'
+require 'api_logger/middleware'
+require 'api_logger/railtie' if defined?(Rails)
+require 'api_logger/generators' if defined?(Rails)
+
+# :nodoc:
+module ApiLogger
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def config
+      configuration
+    end
+
+    def log(endpoint:, http_method: nil, request_headers: nil, request_params: nil, response_body: nil,
+            response_headers: nil, response_status: nil, error_message: nil)
+      return unless configuration.enabled
+
+      request_params = prepare_params(request_params)
+      request_headers = prepare_headers(request_headers)
+      response_body = prepare_response(response_body)
+      response_headers = prepare_headers(response_headers)
+
+      # Create the log entry
+      klass = get_model_class
+      klass.create(
+        endpoint: endpoint.to_s,
+        http_method: http_method,
+        request_headers: request_headers,
+        request_params: request_params,
+        response_body: response_body,
+        response_headers: response_headers,
+        response_status: response_status,
+        error_message: error_message
+      )
+    rescue StandardError => e
+      Rails.logger.error("ApiLogger failed to log request: #{e.message}") if defined?(Rails)
+    end
+
+    private
+
+    def prepare_headers(headers)
+      return nil if headers.nil?
+
+      headers.to_h if headers.respond_to?(:to_h)
+    end
+
+    def prepare_params(params)
+      return nil if params.nil?
+
+      params = params.to_h if params.respond_to?(:to_h)
+      params
+    end
+
+    def prepare_response(response)
+      return nil if response.nil?
+
+      case response
+      when String
+        begin
+          JSON.parse(response)
+        rescue StandardError
+          response
+        end
+      else
+        response
+      end
+    end
+
+    def get_model_class
+      # Dynamically define model class if it doesn't exist
+      model_name = configuration.table_name.classify
+
+      begin
+        model_name.constantize
+      rescue NameError
+        # Define the model class dynamically
+        Object.const_set(model_name, Class.new(ActiveRecord::Base) do
+          self.table_name = ApiLogger.configuration.table_name
+        end)
+      end
+    end
+  end
+end

data/lib/generators/api_logger/install/install_generator.rb

@@ -0,0 +1,29 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module ApiLogger
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def copy_migration
+        template(
+          'create_api_logs.rb.tt',
+          "db/migrate/#{next_migration_number}_create_#{ApiLogger.config.table_name}.rb"
+        )
+      end
+
+      private
+
+      def next_migration_number
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+    end
+  end
+end

data/lib/generators/api_logger/install/templates/create_api_logs.rb.tt

@@ -0,0 +1,20 @@
+class Create<%= ApiLogger.config.table_name.camelize %> < ActiveRecord::Migration<%= Rails::VERSION::MAJOR >= 5 ? "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" : "" %>
+  def change
+    create_table :<%= ApiLogger.config.table_name %> do |t|
+      t.string :endpoint, null: false
+      t.string :http_method
+      t.jsonb :request_params
+      t.jsonb :request_headers
+      t.jsonb :response_headers
+      t.jsonb :response_body
+      t.integer :response_status
+      t.string :error_message
+      t.timestamps
+    end
+
+    add_index :<%= ApiLogger.config.table_name %>, :endpoint
+    add_index :<%= ApiLogger.config.table_name %>, :http_method
+    add_index :<%= ApiLogger.config.table_name %>, :created_at
+    add_index :<%= ApiLogger.config.table_name %>, :response_status
+  end
+end

data/lib/tasks/api_logger_tasks.rake

@@ -0,0 +1,11 @@
+namespace :api_logger do
+  desc "Clean up logs older than a specified age (default: 30 days)"
+  task clean: :environment do
+    days = ENV['DAYS'] || 30
+    table_name = ApiLogger.config.table_name
+    model = ApiLogger.send(:get_model_class)
+
+    deleted = model.where('created_at < ?', Time.now - days.to_i.days).delete_all
+    puts "Deleted #{deleted} records from #{table_name} older than #{days} days"
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: api_logger
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Ashish Rao
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: 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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.57'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.57'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+description: Logs API requests and responses to a database table for monitoring and
+  debugging
+email:
+- ashish.r@superlinearinsights.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/api_logger.rb
+- lib/api_logger/configuration.rb
+- lib/api_logger/generators.rb
+- lib/api_logger/middleware.rb
+- lib/api_logger/railtie.rb
+- lib/api_logger/version.rb
+- lib/generators/api_logger/install/install_generator.rb
+- lib/generators/api_logger/install/templates/create_api_logs.rb.tt
+- lib/tasks/api_logger_tasks.rake
+homepage: https://github.com/Superlinear-Insights/api_logger
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Simple API request/response logger for Rails applications
+test_files: []