lumberjack_redis_device 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bbc9ce42f70e40c813a3d446f7a185d876d5a1475179b9fb58286d0648f7293
-  data.tar.gz: 790abe1f48c28198df3584184ac336a87ea399102f1f6b381786e16de40b114f
+  metadata.gz: 848ce30a84453889a51a97492666fdc53e1c5e8b8299a046814dfb4eaf28c110
+  data.tar.gz: 4e71adc0700954dd842963c0e09be7cdb1ae440c45673938f98cbcec86004bdd
 SHA512:
-  metadata.gz: 2bde67b21c182c709faa85c6ee49b1b39afa063a61eee3563d3e02aaeaad4a98a07951eee02595d7296b155b3824db184272b9def616ff3238d3fa42c1010914
-  data.tar.gz: 9150565938e10b012aeec942cc81d244280abfa01c91c117144ce8cd0c17749ef98736d4a68656369fc1a3dbc20bfc4393fd3fd6cd5ec8299ab434b016bab6c2
+  metadata.gz: 37057976e7025438f3d53798a43b977dd8534c5cecd1265edf66a5dc71c84facdb03d2e489eae1def40ca9335674edca82fec8507dda1f09344505d17bdfb9fd
+  data.tar.gz: 22dcfeacde23ef63f04a97c73e33f99790d18a3bec8c8a13c58891ba9a0e9366ec83131ba98a8c0da13a3c9f48b9e81eee3c0124f6b45b1501b0802929ce9e30

data/.github/dependabot.yml

@@ -0,0 +1,12 @@
+# Dependabot update strategy
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: weekly
+    allow:
+      # Automatically keep all runtime dependencies updated
+      - dependency-name: "*"
+        dependency-type: "production"
+    versioning-strategy: lockfile-only

data/.github/workflows/continuous_integration.yml

@@ -0,0 +1,70 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - main
+      - actions-*
+  pull_request:
+    branches-ignore:
+      - actions-*
+  workflow_dispatch:
+
+env:
+  BUNDLE_CLEAN: "true"
+  BUNDLE_PATH: vendor/bundle
+  BUNDLE_JOBS: 3
+  BUNDLE_RETRY: 3
+
+jobs:
+  build:
+    name: build ruby-${{ matrix.ruby }} ${{ matrix.appraisal }}
+    runs-on: ubuntu-latest
+    services:
+      redis:
+        image: redis
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - ruby: "ruby"
+            standardrb: true
+            yard: true
+          - ruby: "3.0"
+            appraisal: redis_5
+          - ruby: "2.7"
+            appraisal: redis_4
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "${{ matrix.ruby }}"
+      - name: Setup bundler
+        if: matrix.bundler != ''
+        run: |
+          gem uninstall bundler --all
+          gem install bundler --no-document --version ${{ matrix.bundler }}
+      - name: Set Appraisal bundle
+        if: matrix.appraisal != ''
+        run: |
+          echo "using gemfile gemfiles/${{ matrix.appraisal }}.gemfile"
+          bundle config set gemfile "gemfiles/${{ matrix.appraisal }}.gemfile"
+      - name: Install gems
+        run: |
+          bundle update
+      - name: Run Tests
+        run: bundle exec rake
+      - name: standardrb
+        if:   matrix.standardrb == true
+        run:  bundle exec standardrb
+      - name: yard
+        if: matrix.yard == true
+        run:  bundle exec yard --fail-on-warning

data/.standard.yml

@@ -0,0 +1,10 @@
+# I really just have issues with the automatic "semantic blocks"
+
+ruby_version: 2.7
+
+format: progress
+
+ignore:
+  - 'spec/**/*':
+    - Lint/UselessAssignment
+    - Lint/Void

data/CHANGE_LOG.md

@@ -1,3 +1,35 @@
+# Changelog
+All notable changes to this project 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).
+
+## 1.1.0
+
+### Changed
+
+- Bumped lumberjack version to >= 2.0.
+
+### Removed
+
+- Removed support for Ruby < 2.7.
+- Removed dependency on multi_json.
+
+## 1.0.2
+
+## Fixed
+
+- Fixed return value from `exists` to always be a boolean regardless of the version of the redis gem being used.
+
+## 1.0.1
+
+### Added
+
+- Add helper to test if log exists in redis or has been expired
+- Add helper to get the timestamp of the last written log entry
+
 # 1.0.0
 
-* Initial release
+### Added
+
+- Initial release

data/README.md

@@ -1,11 +1,17 @@
 # Lumberjack Redis Device
 
-[![Build Status](https://travis-ci.org/bdurand/lumberjack_redis_device.svg?branch=master)](https://travis-ci.org/bdurand/lumberjack_redis_device)
-[![Maintainability](https://api.codeclimate.com/v1/badges/7785eba72f9a92b686b2/maintainability)](https://codeclimate.com/github/bdurand/lumberjack_redis_device/maintainability)
+[![Continuous Integration](https://github.com/bdurand/lumberjack_redis_device/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/lumberjack_redis_device/actions/workflows/continuous_integration.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/lumberjack_redis_device.svg)](https://badge.fury.io/rb/lumberjack_redis_device)
 
 This is a simple reference implementation of a device for the [lumberjack](https://github.com/bdurand/lumberjack) to send logs to a data store.
 
-Log data will be stored in a Redis list. This will likely not scale to handle permanent or large log storage, but it can be useful as a temporary store in log shipment, or as a debug tool for seeing only recent log entries.
+> [!WARNING]
+> This gem is not intended for high volume production use. It is intended to be a simple way to expose a smallish volume of logs from a remote system via Redis.
+>
+> In a high traffic system, the logs will roll over too quickly to be useful.
+>
+> It can be useful as a temporary store in log shipment, or as a debug tool for seeing only recent log entries.
 
 The number of entries in the list can be capped with the `:limit` paramter on the constructor. An expiration time can also be set on the redis key as well with the `:ttl` parameter.
 
@@ -20,3 +26,37 @@ The log entries can then be read out again with the `read` method. The result wi
 ```ruby
 entries = device.read
 ```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "lumberjack_redis_device"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install lumberjack_redis_device
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+You'll need a redis server running to run the tests. You can spin one up using Docker:
+
+```bash
+$ docker run --rm -p 6379:6379 redis
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/lib/lumberjack/redis_device.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "lumberjack"
+require "redis"
+require "json"
+
+# Lumberjack logging framework with device support for Redis
+module Lumberjack
+  # This Lumberjack device logs output to a redis list. The redis list will automatically truncate
+  # to a given size to prevent running out of memory on the server. This is not intended to be a
+  # scalable logging solution, but it can be useful as an additional logging tool to expose recent logs.
+  class RedisDevice < Device
+    VERSION = ::File.read(::File.join(__dir__, "..", "..", "VERSION")).strip.freeze
+
+    DeviceRegistry.add(:redis, self)
+
+    attr_reader :name, :ttl, :limit
+
+    # Create a device. The name will be used as the key for the log entries in redis.
+    #
+    # The redis object can either be a `Redis` instance or a block that yields a `Redis`
+    # instance.
+    #
+    # You can also specify a time to live in seconds (ttl) and set the limit for the size of the list.
+    def initialize(name:, redis:, limit: 10_000, ttl: nil)
+      @name = name
+      @redis = redis
+      @ttl = ttl.to_i
+      @limit = limit
+    end
+
+    # Write an entry to the list in redis
+    def write(entry)
+      data = entry_as_json(entry)
+      json = dump_json(data)
+      redis.multi do |transaction|
+        transaction.lpush(name, json)
+        transaction.ltrim(name, 0, limit - 1)
+        transaction.expire(name, ttl) if ttl && ttl > 0
+      end
+    end
+
+    # Read a set number of entries from the list. The result will be an array of
+    # Lumberjack::LogEntry objects.
+    def read(count = limit)
+      docs = redis.lrange(name, 0, count - 1)
+      docs.collect { |json| entry_from_json(json) }
+    end
+
+    # Return true if the logs exist in redis. Will return false if the
+    # logs have expired.
+    def exists?
+      retval = redis.exists(name)
+      if retval.is_a?(Integer)
+        retval = (retval > 0)
+      end
+      retval
+    end
+
+    # Return the timestamp of the last log entry.
+    def last_written_at
+      entry = read(1).first
+      entry&.time
+    end
+
+    # Get the datetime format used for formatting time values in log entries.
+    # @return [String, nil] the datetime format string, or nil if no custom format is set
+    def datetime_format
+      @time_formatter&.format
+    end
+
+    # Set the datetime format for formatting time values in log entries.
+    # @param format [String] the datetime format string to use for time formatting
+    def datetime_format=(format)
+      @time_formatter = Lumberjack::Formatter::DateTimeFormatter.new(format)
+    end
+
+    # Get the Redis connection instance.
+    # @return [Redis] the Redis connection, either from the stored instance or by calling the proc
+    def redis
+      if @redis.is_a?(Proc)
+        @redis.call
+      else
+        @redis
+      end
+    end
+
+    private
+
+    def entry_as_json(entry)
+      data = {}
+      set_attribute(data, "timestamp", entry.time.to_f) unless entry.time.nil?
+      set_attribute(data, "time", entry.time)
+      set_attribute(data, "severity", entry.severity_label)
+      set_attribute(data, "progname", entry.progname)
+      set_attribute(data, "pid", entry.pid)
+      set_attribute(data, "message", entry.message)
+      set_attribute(data, "attributes", entry.attributes)
+
+      data = @formatter.format(data) if @formatter
+      data
+    end
+
+    def entry_from_json(json)
+      data = JSON.parse(json)
+      time = Time.at(data["timestamp"]) if data["timestamp"]
+      severity = data["severity"]
+      progname = data["progname"]
+      pid = data["pid"]
+      message = data["message"]
+      attributes = data["attributes"] || data["tags"] # Fallback to tags for compatibility with 1.x format
+      LogEntry.new(time, severity, message, progname, pid, attributes)
+    end
+
+    def set_attribute(data, key, value)
+      return if value.nil?
+
+      if (value.is_a?(Time) || value.is_a?(DateTime)) && @time_formatter
+        value = @time_formatter.call(value)
+      end
+
+      if key.is_a?(Array)
+        unless key.empty?
+          if key.size == 1
+            data[key.first] = value
+          else
+            data[key.first] ||= {}
+            set_attribute(data[key.first], key[1, key.size], value)
+          end
+        end
+      elsif key.respond_to?(:call)
+        hash = key.call(value)
+        if hash.is_a?(Hash)
+          data.merge!(hash)
+        end
+      else
+        data[key] = value unless key.nil?
+      end
+    end
+
+    def default_formatter
+      formatter = Lumberjack::Formatter.new.clear
+      object_formatter = Lumberjack::Formatter::ObjectFormatter.new
+      formatter.add(String, object_formatter)
+      formatter.add(Object, object_formatter)
+      formatter.add(Enumerable, Formatter::StructuredFormatter.new(formatter))
+      formatter.add(Exception, Formatter::InspectFormatter.new)
+    end
+
+    def dump_json(data)
+      JSON.generate(json_safe(data))
+    end
+
+    def json_safe(value)
+      return nil if value.nil?
+
+      # Check if the as_json method is defined takes no parameters
+      as_json_arity = value.method(:as_json).arity if value.respond_to?(:as_json)
+
+      if as_json_arity == 0 || as_json_arity == -1
+        value.as_json
+      elsif value.is_a?(Hash)
+        value.transform_values { |v| json_safe(v) }
+      elsif value.is_a?(Enumerable)
+        value.collect { |v| json_safe(v) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/lumberjack_redis_device.rb

@@ -1,130 +1,3 @@
 # frozen_string_literal: true
 
-require 'lumberjack'
-require 'multi_json'
-require 'redis'
-
-module Lumberjack
-  # This Lumberjack device logs output to a redis list. The redis list will automatically truncate
-  # to a given size to prevent running out of memory on the server. This is not inteneded to be a
-  # scalable logging solution, but it can be useful as an additional logging tool to expose recent logs.
-  class RedisDevice < Device
-
-    attr_reader :name, :ttl, :limit
-
-    # Create a device. The name will be used as the key for the log entris in redis.
-    #
-    # The redis object can either be a `Redis` instance or a block that yields a `Redis`
-    # instance.
-    #
-    # You can also specify a time to live in seconds (ttl) and set the limit for the size of the list.
-    def initialize(name:, redis:, limit: 10_000, ttl: nil)
-      @name = name
-      @redis = redis
-      @ttl = ttl.to_i
-      @limit = limit
-    end
-
-    # Write an entry to the list in redis
-    def write(entry)
-      data = entry_as_json(entry)
-      json = MultiJson.dump(data)
-      redis.multi do |transaction|
-        transaction.lpush(name, json)
-        transaction.ltrim(name, 0, limit - 1)
-        transaction.expire(name, ttl) if ttl && ttl > 0
-      end
-    end
-
-    # Read a set number of entries from the list. The result will be an array of
-    # Lumberjack::LogEntry objects.
-    def read(count = limit)
-      docs = redis.lrange(name, 0, count - 1)
-      docs.collect { |json| entry_from_json(json) }
-    end
-
-    def datetime_format
-      @time_formatter.format if @time_formatter
-    end
-
-    def datetime_format=(format)
-      @time_formatter = Lumberjack::Formatter::DateTimeFormatter.new(format)
-    end
-
-    def redis
-      if @redis.is_a?(Proc)
-        @redis.call
-      else
-        @redis
-      end
-    end
-
-    private
-
-    def entry_as_json(entry)
-      data = {}
-      set_attribute(data, "timestamp", entry.time.to_f) unless entry.time.nil?
-      set_attribute(data, "time", entry.time)
-      set_attribute(data, "severity", entry.severity_label)
-      set_attribute(data, "progname", entry.progname)
-      set_attribute(data, "pid", entry.pid)
-      set_attribute(data, "message", entry.message)
-      set_attribute(data, "tags", entry.tags)
-
-      unless @tags_key.nil?
-        tags ||= {}
-        set_attribute(data, @tags_key, tags)
-      end
-
-      data = @formatter.format(data) if @formatter
-      data
-    end
-
-    def entry_from_json(json)
-      data = MultiJson.load(json)
-      time = Time.at(data["timestamp"]) if data["timestamp"]
-      severity = data["severity"]
-      progname = data["progname"]
-      pid = data["pid"]
-      message = data["message"]
-      tags = data["tags"]
-      LogEntry.new(time, severity, message, progname, pid, tags)
-    end
-
-    def set_attribute(data, key, value)
-      return if value.nil?
-
-      if (value.is_a?(Time) || value.is_a?(DateTime)) && @time_formatter
-        value = @time_formatter.call(value)
-      end
-
-      if key.is_a?(Array)
-        unless key.empty?
-          if key.size == 1
-            data[key.first] = value
-          else
-            data[key.first] ||= {}
-            set_attribute(data[key.first], key[1, key.size], value)
-          end
-        end
-      elsif key.respond_to?(:call)
-        hash = key.call(value)
-        if hash.is_a?(Hash)
-          data.merge!(Lumberjack::Tags.stringify_keys(hash))
-        end
-      else
-        data[key] = value unless key.nil?
-      end
-    end
-
-    def default_formatter
-      formatter = Formatter.new.clear
-      object_formatter = Lumberjack::Formatter::ObjectFormatter.new
-      formatter.add(String, object_formatter)
-      formatter.add(Object, object_formatter)
-      formatter.add(Enumerable, Formatter::StructuredFormatter.new(formatter))
-      formatter.add(Exception, Formatter::InspectFormatter.new)
-    end
-
-  end
-end
+require_relative "lumberjack/redis_device"

data/lumberjack_redis_device.gemspec

@@ -1,16 +1,22 @@
 Gem::Specification.new do |spec|
-  spec.name = 'lumberjack_redis_device'
-  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
-  spec.authors = ['Brian Durand']
-  spec.email = ['bbdurand@gmail.com']
+  spec.name = "lumberjack_redis_device"
+  spec.version = File.read(File.join(__dir__, "VERSION")).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
 
   spec.summary = "A logging device for the lumberjack gem that writes log entries as JSON documentspec."
   spec.homepage = "https://github.com/bdurand/lumberjack_redis_device"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGE_LOG.md"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  ignore_files = %w(
+  ignore_files = %w[
     .gitignore
     .travis.yml
     Appraisals
@@ -19,18 +25,17 @@ Gem::Specification.new do |spec|
     Rakefile
     gemfiles/
     spec/
-  )
-  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject{ |f| ignore_files.any?{ |path| f.start_with?(path) } }
+  ]
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
   end
 
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">=2.7"
 
-  spec.add_dependency "lumberjack", ">=1.1"
-  spec.add_dependency "multi_json"
+  spec.add_dependency "lumberjack", ">=2.0"
   spec.add_dependency "redis"
 
-  spec.add_development_dependency("rspec", ["~> 3.0"])
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "fakeredis"
+  spec.add_development_dependency "bundler"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack_redis_device
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Brian Durand
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lumberjack
@@ -16,28 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -53,35 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: fakeredis
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,24 +51,29 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
 email:
 - bbdurand@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/workflows/continuous_integration.yml"
+- ".standard.yml"
 - CHANGE_LOG.md
-- MIT_LICENSE
+- MIT_LICENSE.txt
 - README.md
 - VERSION
+- lib/lumberjack/redis_device.rb
 - lib/lumberjack_redis_device.rb
 - lumberjack_redis_device.gemspec
 homepage: https://github.com/bdurand/lumberjack_redis_device
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/bdurand/lumberjack_redis_device
+  source_code_uri: https://github.com/bdurand/lumberjack_redis_device
+  changelog_uri: https://github.com/bdurand/lumberjack_redis_device/blob/main/CHANGE_LOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -119,15 +81,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A logging device for the lumberjack gem that writes log entries as JSON documentspec.
 test_files: []