log_cleaner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d17979e59d30220cfa00c0855182bb6bfce4b8ddd7730b1eeec26cc51850154
+  data.tar.gz: e449a27cfd787627bd9dfce4c6c715392a1dc4fa27b7e98b7ba6d66386dacbcd
+SHA512:
+  metadata.gz: b4cffd66bf203dd0d9f7e93a89cca8e32fae55f3a8cd6a6241eb7d677c60a9c7d7d1114fe84103b72c6ca08eeacecb01fc7e01b0c286f43e37c6b9b13911e43c
+  data.tar.gz: f8ee1541a231494dd027b935e40b2657655514cc5154ac64a032fb40a49a0df86a40fdb1c545d070070a30434b51f6f716fc674eefb864a4775a4f8a1929a3de

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [0.1.0] - 2026-01-18
+
+### Added
+- Structured JSON logging
+- Automatic masking of sensitive fields (password, tokens, etc.)
+- Request ID injection
+- Request middleware support
+- Controller request logging
+- ActiveRecord SQL logging
+- Configurable mask fields
+
+### Security
+- Prevents leaking sensitive data into logs

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,19 @@
+
+✅ This will also appear on RubyGems automatically once published.  
+
+---
+
+## 2️⃣ Create a Git Tag for your release
+
+Before you can see tags with `git tag -l`, you must **create a tag**. Example for version `0.1.0`:
+
+```bash
+# Stage and commit all changes (including README and version)
+git add .
+git commit -m "Release v0.1.0"
+
+# Create a git tag
+git tag v0.1.0
+
+# Push commits and tags
+git push origin main --tags

data/README.md

@@ -0,0 +1,147 @@
+# LogCleaner
+
+LogCleaner is a Ruby gem for **structured JSON logging** with automatic **masking of sensitive fields** such as passwords, emails, and authentication tokens. It works with Rails controllers, middleware, and ActiveRecord models.
+
+---
+
+## Features
+
+- Structured JSON logs for Rails controllers and ActiveRecord
+- Automatic masking of sensitive fields (`password`, `email`, `authenticity_token`, etc.)
+- Middleware support for request IDs
+- Configurable mask fields per environment
+- Supports custom log messages
+
+---
+
+## Installation
+
+### 1. Add the Gem
+
+Add `log_cleaner` to your Gemfile:
+
+```ruby
+# Gemfile
+gem 'log_cleaner'
+```
+
+Then install the gem:
+```
+bundle install
+```
+## Create an Initializer
+
+```Create a file for configuring masked fields:
+touch config/initializers/log_cleaner.rb
+```
+Add the following content:
+```
+# config/initializers/log_cleaner.rb
+LogCleaner.configure do |c|
+  if Rails.env.production?
+    # Mask sensitive fields in production
+    c.mask_fields = [:email, :password, :authenticity_token]
+  else
+    # Only mask password and authenticity_token in development
+    c.mask_fields = [:password, :authenticity_token]
+  end
+end
+```
+
+✅ This ensures sensitive data is masked automatically in logs.
+
+## Include in ApplicationController
+
+```Include LogCleaner::RequestLogger to clean logs for every request:
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  include LogCleaner::RequestLogger
+end
+```
+
+## Restart Rails Server
+
+```After making changes, restart your Rails server:
+rails server
+```
+
+## Verify Logs
+
+Check your server logs (log/development.log or log/production.log) to see masked fields.
+
+Example output:
+
+```
+**************************************************
+{
+  "timestamp": "2026-01-17T18:03:37Z",
+  "level": "info",
+  "request_id": "req-97efe591",
+  "event": "controller_request",
+  "controller": "omniauth",
+  "action": "username_password_authenticate",
+  "status": 302,
+  "duration_ms": 492.15,
+  "params": {
+    "authenticity_token": "[FILTERED]",
+    "session": "[FILTERED]",
+    "commit": "Login",
+    "controller": "omniauth",
+    "action": "username_password_authenticate"
+  },
+  "request_body": {},
+  "url": "http://lms-in.yabx.local:3000/authenticate",
+  "method": "POST",
+  "ip": "127.0.0.1",
+  "user_id": 1
+}
+**************************************************
+```
+
+## Adding Custom Logs if you want then
+
+You can log custom messages while keeping sensitive fields masked, Add this line for any action or any place:
+
+```
+LogCleaner.log("Custom Info: User signup started", current_user: current_user.id)
+```
+Example log output:
+
+```
+[INFO] Custom Info: User signup started {"current_user": 1}
+```
+
+Note: You can change the key or value according your own requirments.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub: [LogCleaner](https://github.com/shubham-chauhan-dev/log_cleaner)
+
+1. Fork the repository
+2. Create a branch (git checkout -b feature-name)
+3. Make your changes
+4. Submit a pull request
+
+
+## License
+
+
+---
+
+This README is **fully complete**:
+
+- ✅ Installation steps  
+- ✅ Initializer setup with masked fields  
+- ✅ Controller integration  
+- ✅ ActiveRecord logging example  
+- ✅ Middleware usage  
+- ✅ Custom logs  
+- ✅ Proper Markdown formatting  
+- ✅ GitHub link in Contributing section  
+
+---
+
+If you want, I can also **prepare a `docs/` folder with screenshots and example logs** that match this README so you can attach them for visual documentation.  
+
+Do you want me to do that next?

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/log_cleaner/active_record_logger.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+# LogCleaner::ActiveRecordLogger is a concern for ActiveRecord models
+# that automatically logs validation errors after the model is validated.
+#
+# Features:
+# - Hooks into ActiveRecord's `after_validation` callback.
+# - Logs all validation errors with model name, attributes, and user context.
+# - Uses LogCleaner.error to standardize log structure.
+#
+# Example usage in a Rails model:
+#
+#   class User < ApplicationRecord
+#     include LogCleaner::ActiveRecordLogger
+#   end
+#
+# When a User model fails validation, a structured log is sent to LogCleaner:
+#   LogCleaner.error(
+#     event: "model_validation_failed",
+#     model: "User",
+#     attributes: { name: "John", email: "invalid" },
+#     errors: { email: ["is invalid"] },
+#     user_id: 1
+#   )
+module LogCleaner
+  # ActiveRecordLogger
+  module ActiveRecordLogger
+    extend ActiveSupport::Concern
+
+    included do
+      # Hook after validation
+      after_validation :log_validation_errors, if: -> { errors.any? }
+    end
+
+    private
+
+    def log_validation_errors
+      LogCleaner.error(
+        event: "model_validation_failed",
+        model: self.class.name,
+        attributes: attributes.slice(*self.class.attribute_names),
+        errors: errors.to_hash,
+        user_id: defined?(current_user) ? current_user&.id : nil
+      )
+    end
+  end
+end

data/lib/log_cleaner/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+LogCleaner::Engine.routes.draw do
+  root to: "dashboard#index"
+end

data/lib/log_cleaner/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# LogCleaner::Config handles the configuration settings for the LogCleaner module.
+#
+# Features:
+# - Stores configurable options for LogCleaner, such as fields that should be masked in logs.
+# - Provides a central place to manage logging behavior across the application.
+#
+# Configuration example:
+#
+#   LogCleaner.configure do |config|
+#     config.mask_fields = [:password, :credit_card_number]
+#   end
+#
+# This ensures that sensitive fields are masked in all logs handled by LogCleaner.
+module LogCleaner
+  # Config
+  class Config
+    attr_accessor :mask_fields
+
+    def initialize
+      @mask_fields = []
+    end
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+end

data/lib/log_cleaner/engine.rb

@@ -0,0 +1,36 @@
+# lib/log_cleaner/engine.rb
+# typed: false
+# frozen_string_literal: true
+
+require "rails"
+
+# LogCleaner::Engine integrates the LogCleaner gem into a Rails application
+# as a Rails Engine. This allows LogCleaner to provide middleware,
+# request logging, and other Rails-specific features seamlessly.
+#
+# Features:
+# - Isolates the LogCleaner namespace to avoid conflicts with the host app.
+# - Can include Rails initializers for assets, middleware, or configuration.
+#
+# Example:
+#   # In a Rails app, LogCleaner will automatically mount its engine and
+#   # integrate middleware for request-level logging.
+#
+# Notes:
+# - The asset precompilation block is optional and can be uncommented if
+#   LogCleaner ships with CSS/JS assets for a dashboard or UI.
+
+module LogCleaner
+  # Enginee
+  class Engine < ::Rails::Engine
+    isolate_namespace LogCleaner
+
+    # No need to precompile assets if you are using inline CSS/JS
+    # initializer "log_cleaner.assets.precompile" do |app|
+    #   app.config.assets.precompile += %w[
+    #     log_cleaner/dashboard.css
+    #     log_cleaner/dashboard.js
+    #   ]
+    # end
+  end
+end

data/lib/log_cleaner/logger.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "logger"
+require "time" # Needed for iso8601 timestamps
+require_relative "request_store"
+require_relative "config"
+
+# LogCleaner
+module LogCleaner
+  # logger
+  class Logger
+    def initialize
+      # Standard Ruby Logger, output to stdout
+      @logger = ::Logger.new($stdout)
+      # Formatter: print ONLY the message (our JSON), no Ruby Logger prefix
+      @logger.formatter = ->(_severity, _datetime, _progname, msg) { "#{msg}\n" }
+    end
+
+    # Public methods for log levels
+    def info(data)
+      log("info", data)
+    end
+
+    def debug(data)
+      log("debug", data)
+    end
+
+    def warn(data)
+      log("warn", data)
+    end
+
+    def error(data)
+      log("error", data)
+    end
+
+    private
+
+    # Core logging logic
+    def log(level, data)
+      payload = build_payload(level, data)
+      json_pretty = JSON.pretty_generate(payload)
+
+      formatted_msg = "\n#{"*" * 50}\n#{json_pretty}\n#{"*" * 50}\n"
+
+      @logger.public_send(level, formatted_msg)
+    end
+
+    # Build structured JSON payload
+    def build_payload(level, data)
+      filtered_data = mask_sensitive(data)
+
+      {
+        timestamp: Time.now.utc.iso8601,
+        level: level,
+        request_id: RequestStore.request_id || "req-#{SecureRandom.hex(4)}"
+      }.merge(filtered_data)
+    end
+
+    # Recursive masking for nested hashes and arrays
+    def mask_sensitive(data)
+      case data
+      when Hash
+        mask_sensitive_for_hash(data)
+      when Array
+        data.map { |v| mask_sensitive(v) }
+      else
+        data
+      end
+    end
+
+    def mask_sensitive_for_hash(data)
+      data.each_with_object({}) do |(key, value), result|
+        key_sym = safe_to_sym(key)
+        result[key_sym] = mask_sensitive_fileds?(key_sym, value)
+      end
+    end
+
+    def mask_sensitive_fileds?(key_sym, value)
+      LogCleaner.config.mask_fields.include?(key_sym) ? "[FILTERED]" : mask_sensitive(value)
+    end
+
+    # Safely convert a key to symbol
+    def safe_to_sym(key)
+      key.to_sym
+    rescue StandardError
+      key
+    end
+    private :safe_to_sym
+  end
+
+  # Singleton logger instance
+  def self.logger
+    @logger ||= Logger.new
+  end
+
+  # Convenience methods
+  def self.info(data)
+    logger.info(data)
+  end
+
+  def self.debug(data)
+    logger.debug(data)
+  end
+
+  def self.warn(data)
+    logger.warn(data)
+  end
+
+  def self.error(data)
+    logger.error(data)
+  end
+end

data/lib/log_cleaner/request_logger.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+# LogCleaner::RequestLogger is a Rails controller concern that automatically
+# logs request and response information for every controller action.
+#
+# Features:
+# - Wraps controller actions using `around_action` to capture execution time.
+# - Logs structured JSON containing:
+#     - Event type ("controller_request")
+#     - Controller and action names
+#     - HTTP status code
+#     - Request duration in milliseconds
+#     - Request parameters (with sensitive fields masked)
+#     - Request body (with sensitive fields masked)
+#     - URL, HTTP method, client IP
+#     - User ID (if `current_user` is defined)
+# - Allows manual addition of extra log fields using `log_cleaner_info`.
+# - Integrates with LogCleaner.logger for centralized logging.
+#
+# Usage:
+#
+#   class ApplicationController < ActionController::Base
+#     include LogCleaner::RequestLogger
+#   end
+#
+# Masking sensitive fields can be configured globally:
+#
+#   LogCleaner.configure do |config|
+#     config.mask_fields = [:password, :credit_card_number]
+#   end
+#
+# Example log output:
+#
+#   {
+#     "timestamp": "...",
+#     "level": "info",
+#     "request_id": "req-abc123",
+#     "event": "controller_request",
+#     "controller": "users",
+#     "action": "create",
+#     "status": 201,
+#     "duration_ms": 42.15,
+#     "params": { "email": "user@example.com", "password": "[FILTERED]" },
+#     "request_body": { "password": "[FILTERED]" },
+#     "url": "http://localhost:3000/users",
+#     "method": "POST",
+#     "ip": "127.0.0.1",
+#     "user_id": 1
+#   }
+module LogCleaner
+  # RequestLogger
+  module RequestLogger
+    extend ActiveSupport::Concern
+
+    included do
+      around_action :log_request
+    end
+
+    private
+
+    # Main logging wrapper
+    def log_request
+      start_time = Time.now
+      yield
+    ensure
+      duration = ((Time.now - start_time) * 1000).round(2) # ms
+
+      # Merge default log info with any manual info set in @log_cleaner_manual_info
+      log_data = prepare_hash_data(duration)
+
+      # Merge any manual info passed via LogCleaner.info call in controller
+      log_data.merge!(@log_cleaner_manual_info) if defined?(@log_cleaner_manual_info)
+
+      # Perform logging
+      LogCleaner.info(log_data)
+    end
+
+    def prepare_hash_data(duration)
+      { event: "controller_request", controller: controller_name, action: action_name,
+        status: safe_status, duration_ms: duration, params: safe_filtered_params,
+        request_body: safe_request_body, url: request.url, method: request.request_method,
+        ip: request.remote_ip, user_id: safe_user_id }
+    end
+
+    # Safe response status
+    def safe_status
+      response&.status || 0
+    end
+
+    # Recursively mask params
+    def safe_filtered_params
+      return {} unless params.respond_to?(:to_unsafe_h)
+
+      deep_mask(params.to_unsafe_h, LogCleaner.config.mask_fields)
+    end
+
+    # Recursively mask request_body
+    def safe_request_body
+      body = request.body.read
+      request.body.rewind
+      parsed = JSON.parse(body)
+      deep_mask(parsed, LogCleaner.config.mask_fields)
+    rescue JSON::ParserError, TypeError
+      {}
+    end
+
+    # Recursive masking helper
+    def deep_mask(obj, mask_fields)
+      case obj
+      when Array
+        obj.map { |v| deep_mask(v, mask_fields) }
+
+      when Hash, ActionController::Parameters
+        deep_mask_for_hash?(obj, mask_fields)
+      else
+        obj
+      end
+    end
+
+    def deep_mask_for_hash?(obj, mask_fields)
+      obj.to_h.each_with_object({}) do |(k, v), result|
+        key = begin
+          k.to_sym
+        rescue StandardError
+          k
+        end
+
+        result[key] = mask_fields.include?(key) ? "[FILTERED]" : deep_mask(v, mask_fields)
+      end
+    end
+
+    # Safe current_user logging
+    def safe_user_id
+      u = defined?(current_user) ? current_user : nil
+      if u.is_a?(Array)
+        u.first&.id
+      else
+        u&.id
+      end
+    end
+
+    # **Helper to allow direct LogCleaner.info calls with custom info**
+    def log_cleaner_info(info = {})
+      @log_cleaner_manual_info = info
+      LogCleaner.info(info)
+    end
+  end
+end

data/lib/log_cleaner/request_middleware.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+# LogCleaner::RequestMiddleware is a Rack middleware that assigns a unique
+# request ID to each incoming HTTP request. This ID is stored in
+# RequestStore and is used for correlating logs throughout the request lifecycle.
+#
+# It ensures:
+# - A unique `request_id` is available for every request.
+# - The request ID is cleared after the request completes to prevent leakage.
+#
+# Example usage in Rails:
+#
+#   Rails.application.config.middleware.use LogCleaner::RequestMiddleware
+module LogCleaner
+  # Middleware
+  class RequestMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # Assign a unique request ID per HTTP request
+      RequestStore.request_id = "req-#{SecureRandom.hex(4)}"
+      @app.call(env)
+    ensure
+      # Clear the thread after request ends to prevent leakage
+      RequestStore.request_id = nil
+    end
+  end
+end

data/lib/log_cleaner/request_store.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# LogCleaner::RequestStore provides thread-local storage for per-request data,
+# specifically the `request_id`. This allows logs to be correlated across
+# different parts of the application during a single HTTP request.
+#
+# Features:
+# - Stores a unique request ID in thread-local storage.
+# - Ensures each request's ID is isolated and cleared after the request ends.
+#
+# Example usage:
+#
+#   # Assign a request ID
+#   LogCleaner::RequestStore.request_id = "req-abc123"
+#
+#   # Retrieve the current request ID
+#   LogCleaner::RequestStore.request_id
+module LogCleaner
+  # Request store
+  module RequestStore
+    def self.request_id
+      Thread.current[:log_cleaner_request_id]
+    end
+
+    def self.request_id=(id)
+      Thread.current[:log_cleaner_request_id] = id
+    end
+  end
+end

data/lib/log_cleaner/version.rb

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

data/lib/log_cleaner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "logger"
+require "time"
+
+require_relative "log_cleaner/version"
+require_relative "log_cleaner/config"
+require_relative "log_cleaner/request_store"
+require_relative "log_cleaner/logger"
+require_relative "log_cleaner/request_middleware"
+require_relative "log_cleaner/request_logger"
+require_relative "log_cleaner/active_record_logger"
+require_relative "log_cleaner/engine"
+
+# LogCleaner is a Ruby library that provides structured logging
+# and request-level log management for applications.
+#
+# It allows you to:
+# - Automatically capture and clean logs for HTTP requests.
+# - Track logs per request using RequestStore.
+# - Integrate with ActiveRecord for database query logging.
+# - Configure logging behavior using a central configuration object.
+#
+# Example usage:
+#
+#   LogCleaner.configure do |config|
+#     config.log_level = :info
+#     config.clean_sensitive_data = true
+#   end
+#
+# The library also provides middleware for Rack/Rails applications
+# to capture request-specific logs and a custom logger for structured output.
+module LogCleaner
+  class << self
+    attr_accessor :config
+  end
+
+  # Configuration
+  def self.configure
+    self.config ||= Config.new
+    yield(config)
+  end
+end

data/sig/log_cleaner.rbs

@@ -0,0 +1,4 @@
+module LogCleaner
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: log_cleaner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shubham Chauhan
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  LogCleaner provides structured JSON logging with automatic masking of
+                                  sensitive fields like passwords and authentication tokens across requests,
+                                  controllers, and ActiveRecord.
+email:
+- shubham.chauhan@yabx.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/.DS_Store
+- lib/log_cleaner.rb
+- lib/log_cleaner/.DS_Store
+- lib/log_cleaner/active_record_logger.rb
+- lib/log_cleaner/config.rb
+- lib/log_cleaner/config/routes.rb
+- lib/log_cleaner/engine.rb
+- lib/log_cleaner/logger.rb
+- lib/log_cleaner/request_logger.rb
+- lib/log_cleaner/request_middleware.rb
+- lib/log_cleaner/request_store.rb
+- lib/log_cleaner/version.rb
+- sig/log_cleaner.rbs
+homepage: https://github.com/shubham-chauhan-dev/log_cleaner
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/shubham-chauhan-dev/log_cleaner
+  source_code_uri: https://github.com/shubham-chauhan-dev/log_cleaner
+  changelog_uri: https://github.com/shubham-chauhan-dev/log_cleaner/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Structured logging with automatic sensitive data masking
+test_files: []