philiprehberger-log_filter 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3b4641d0484bf50c2cc4b567eae1af24be89009b8e85c74b9e603f10ec835f63
+  data.tar.gz: d79d7ff53b0fe31b17ead3ea34d05006c856408ee7c88bf7c6eedf6f4bca808e
+SHA512:
+  metadata.gz: 84988453f7ab48620e52056c05f41bae19a7963a8e008aef5e5e9320d92c5d5b7afb1697afeecfb6597c4a094f3090fcf84f7e3950e2459369d76f018576a098
+  data.tar.gz: 39aef2aa4d1f08094a5f77a91535ceadb09d6ff506b068ee4fc56b4dc9ae48840f6fb6fb0e973d03216fce40fd424d53cc8b1e91b501235f145e4eb030b51c2c

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this gem will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.2] - 2026-03-13
+
+### Fixed
+- Fix RuboCop ExtraSpacing offense in gemspec metadata
+
+## [0.1.0] - 2026-03-13
+
+### Added
+- Initial release
+- `Filter` class with `#drop`, `#drop_if`, and `#replace` rules
+- `Wrapper` class for wrapping Ruby Logger with filter support
+- `Presets` module with `health_check`, `assets`, and `bots` factory methods
+- Convenience methods on `Philiprehberger::LogFilter` module

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 philiprehberger
+
+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:
+
+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.

data/README.md

@@ -0,0 +1,117 @@
+# philiprehberger-log_filter
+
+[![Tests](https://github.com/philiprehberger/rb-log-filter/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-log-filter/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/philiprehberger-log_filter.svg)](https://rubygems.org/gems/philiprehberger-log_filter)
+
+Pattern-based log filtering with drop, replace, and preset rules.
+
+## Requirements
+
+- Ruby >= 3.1
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "philiprehberger-log_filter"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install philiprehberger-log_filter
+```
+
+## Usage
+
+```ruby
+require "philiprehberger/log_filter"
+
+# Build a custom filter chain
+filter = Philiprehberger::LogFilter::Filter.new
+  .drop(/health_?check/i)
+  .drop(/DEBUG/)
+  .replace(/password=\S+/, "password=[REDACTED]")
+
+filter.apply("GET /healthcheck 200")       # => nil (dropped)
+filter.apply("DEBUG some noise")            # => nil (dropped)
+filter.apply("login password=abc123")       # => "login password=[REDACTED]"
+filter.apply("GET /api/users 200")          # => "GET /api/users 200"
+```
+
+### Wrapping a Logger
+
+```ruby
+require "logger"
+require "philiprehberger/log_filter"
+
+logger = Logger.new($stdout)
+filter = Philiprehberger::LogFilter::Filter.new
+  .drop(/healthcheck/i)
+  .replace(/token=\S+/, "token=[REDACTED]")
+
+filtered_logger = Philiprehberger::LogFilter.wrap(logger, filter)
+
+filtered_logger.info("GET /healthcheck 200")    # silently dropped
+filtered_logger.info("auth token=secret123")     # logs "auth token=[REDACTED]"
+filtered_logger.info("GET /api/users 200")       # logs normally
+```
+
+### Using Presets
+
+```ruby
+# Drop health-check noise
+filter = Philiprehberger::LogFilter.health_check_filter
+filtered_logger = Philiprehberger::LogFilter.wrap(logger, filter)
+
+# Drop static asset requests
+filter = Philiprehberger::LogFilter.asset_filter
+
+# Drop bot/crawler traffic
+filter = Philiprehberger::LogFilter.bot_filter
+```
+
+### Block-Based Drop Rules
+
+```ruby
+filter = Philiprehberger::LogFilter::Filter.new
+  .drop_if { |msg| msg.length > 1000 }   # drop excessively long messages
+  .drop_if { |msg| msg.count("\n") > 10 } # drop multi-line spam
+```
+
+## API
+
+| Class / Method | Description |
+|----------------|-------------|
+| `Filter.new` | Create a new empty filter chain |
+| `Filter#drop(pattern)` | Add a regex drop rule; returns self |
+| `Filter#drop_if(&block)` | Add a block-based drop rule; returns self |
+| `Filter#replace(pattern, replacement)` | Add a replacement rule; returns self |
+| `Filter#apply(message)` | Run all rules; returns transformed string or nil |
+| `Wrapper.new(logger, filter)` | Wrap a Logger with a filter |
+| `Presets.health_check` | Filter dropping health-check paths |
+| `Presets.assets` | Filter dropping static-asset requests |
+| `Presets.bots` | Filter dropping bot/crawler traffic |
+| `LogFilter.wrap(logger, filter)` | Convenience wrapper constructor |
+| `LogFilter.health_check_filter` | Shortcut for `Presets.health_check` |
+| `LogFilter.asset_filter` | Shortcut for `Presets.assets` |
+| `LogFilter.bot_filter` | Shortcut for `Presets.bots` |
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec      # Run tests
+bundle exec rubocop    # Check code style
+```
+
+## License
+
+MIT

data/lib/philiprehberger/log_filter/filter.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module LogFilter
+    # Chain of rules that can drop or transform log messages.
+    #
+    # Rules are evaluated in the order they were added. A drop rule
+    # short-circuits and returns +nil+. A replace rule mutates the
+    # message string before passing it to the next rule.
+    class Filter
+      # @return [Array<Hash>] the ordered list of rules
+      attr_reader :rules
+
+      def initialize
+        @rules = []
+      end
+
+      # Add a pattern-based drop rule. Messages matching +pattern+ are suppressed.
+      #
+      # @param pattern [Regexp] the pattern to match against
+      # @return [self] for chaining
+      def drop(pattern)
+        @rules << { type: :drop_pattern, pattern: pattern }
+        self
+      end
+
+      # Add a block-based drop rule. Messages for which the block returns
+      # a truthy value are suppressed.
+      #
+      # @yield [message] evaluates whether the message should be dropped
+      # @yieldparam message [String]
+      # @yieldreturn [Boolean]
+      # @return [self] for chaining
+      def drop_if(&block)
+        @rules << { type: :drop_block, block: block }
+        self
+      end
+
+      # Add a replacement rule. Occurrences of +pattern+ in the message
+      # are replaced with +replacement+.
+      #
+      # @param pattern [Regexp] the pattern to match
+      # @param replacement [String] the replacement string
+      # @return [self] for chaining
+      def replace(pattern, replacement)
+        @rules << { type: :replace, pattern: pattern, replacement: replacement }
+        self
+      end
+
+      # Run all rules against +message+ in order.
+      #
+      # @param message [String] the log message to filter
+      # @return [String, nil] the transformed message, or +nil+ if dropped
+      def apply(message)
+        result = message.dup
+
+        @rules.each do |rule|
+          result = apply_rule(rule, result)
+          return nil if result.nil?
+        end
+
+        result
+      end
+
+      private
+
+      # @param rule [Hash] a single rule hash
+      # @param message [String] the current message
+      # @return [String, nil]
+      def apply_rule(rule, message)
+        case rule[:type]
+        when :drop_pattern then message.match?(rule[:pattern]) ? nil : message
+        when :drop_block   then rule[:block].call(message) ? nil : message
+        when :replace      then message.gsub(rule[:pattern], rule[:replacement])
+        end
+      end
+    end
+  end
+end

data/lib/philiprehberger/log_filter/presets.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module LogFilter
+    # Factory methods that return pre-configured {Filter} instances for
+    # common log-noise scenarios.
+    module Presets
+      # Filter that drops health-check request log lines.
+      #
+      # @return [Filter] a filter suppressing health-check paths
+      def self.health_check
+        Filter.new.drop(%r{health_?check|/health|/ping|/ready|/alive}i)
+      end
+
+      # Filter that drops static-asset request log lines.
+      #
+      # @return [Filter] a filter suppressing asset paths
+      def self.assets
+        Filter.new.drop(/\.(css|js|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|map)\b/i)
+      end
+
+      # Filter that drops bot/crawler request log lines.
+      #
+      # @return [Filter] a filter suppressing bot user-agents
+      def self.bots
+        Filter.new.drop(/bot|crawler|spider|slurp|googlebot|bingbot/i)
+      end
+    end
+  end
+end

data/lib/philiprehberger/log_filter/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module LogFilter
+    VERSION = "0.1.2"
+  end
+end

data/lib/philiprehberger/log_filter/wrapper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module LogFilter
+    # Wraps a Ruby Logger (or any object responding to the standard log
+    # level methods) and applies a {Filter} to every message before
+    # forwarding.
+    class Wrapper
+      LOG_LEVELS = %i[debug info warn error fatal].freeze
+
+      # @param logger [Logger] the underlying logger to delegate to
+      # @param filter [Filter] the filter to apply to messages
+      def initialize(logger, filter)
+        @logger = logger
+        @filter = filter
+      end
+
+      LOG_LEVELS.each do |level|
+        # @param message [String, nil] the log message
+        # @param args [Array] additional positional arguments
+        # @return [void]
+        define_method(level) do |message = nil, *args, &block|
+          message = block&.call if message.nil? && block
+          return if message.nil?
+
+          filtered = @filter.apply(message.to_s)
+          return if filtered.nil?
+
+          @logger.public_send(level, filtered, *args)
+        end
+      end
+
+      # @return [Integer] the current log level
+      def level
+        @logger.level
+      end
+
+      # @param new_level [Integer, Symbol] the new log level
+      # @return [void]
+      def level=(new_level)
+        @logger.level = new_level
+      end
+
+      # Close the underlying logger.
+      #
+      # @return [void]
+      def close
+        @logger.close
+      end
+
+      # Delegate unknown methods to the underlying logger.
+      def method_missing(method_name, ...)
+        if @logger.respond_to?(method_name)
+          @logger.public_send(method_name, ...)
+        else
+          super
+        end
+      end
+
+      # @return [Boolean]
+      def respond_to_missing?(method_name, include_private = false)
+        @logger.respond_to?(method_name, include_private) || super
+      end
+    end
+  end
+end

data/lib/philiprehberger/log_filter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "log_filter/version"
+require_relative "log_filter/filter"
+require_relative "log_filter/wrapper"
+require_relative "log_filter/presets"
+
+module Philiprehberger
+  module LogFilter
+    class Error < StandardError; end
+
+    def self.health_check_filter
+      Presets.health_check
+    end
+
+    def self.asset_filter
+      Presets.assets
+    end
+
+    def self.bot_filter
+      Presets.bots
+    end
+
+    def self.wrap(logger, filter)
+      Wrapper.new(logger, filter)
+    end
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: philiprehberger-log_filter
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Philip Rehberger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-13 00:00:00.000000000 Z
+dependencies: []
+description: Pattern-based log filtering — drop or transform log lines matching rules.
+  Includes preset filters for health checks, static assets, and bot traffic.
+email:
+- me@philiprehberger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/philiprehberger/log_filter.rb
+- lib/philiprehberger/log_filter/filter.rb
+- lib/philiprehberger/log_filter/presets.rb
+- lib/philiprehberger/log_filter/version.rb
+- lib/philiprehberger/log_filter/wrapper.rb
+homepage: https://github.com/philiprehberger/rb-log-filter
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/philiprehberger/rb-log-filter
+  source_code_uri: https://github.com/philiprehberger/rb-log-filter
+  changelog_uri: https://github.com/philiprehberger/rb-log-filter/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+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.5.22
+signing_key:
+specification_version: 4
+summary: Pattern-based log filtering with drop, replace, and preset rules
+test_files: []