json_tagged_logger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d9b6a0f1e36ce3cc9e4bc89ea942c6ecea3868d240f58230604c30c954232a2
+  data.tar.gz: 10acc0b50c43dd4d938920a315e11aad21b860022397f4e36273e98f3f4d9192
+SHA512:
+  metadata.gz: 19ee0ae1fa6341aafb6443c21d805e6e787e7bcd5f8e7447a42a38b428925f47a88b101025e3beef34e2db1b74c968ce2ff819374897c8d2d848253cbb9c27c3
+  data.tar.gz: c5697f900381e3d33862b1ff750385ea4feb7a8e05723f719c1b3853a09f7d1336ae7a332caf3fa8b9684c3482019b2bfb319a4cd7ef9b35a5b9a1737addc9f9

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Sean Santry
+
+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,89 @@
+# JsonTaggedLogger
+
+JsonTaggedLogger provides a log formatter that works in conjunction with ActiveSupport::TaggedLogging to product JSON-formatted log output.
+
+
+```ruby
+# Gemfile
+gem 'json_tagged_logger'
+
+# config/environments/production.rb
+Rails.application.configure do
+	# …
+	config.log_tags = JsonTaggedLogger::LogTagsConfig.generate(:request_id, :host, ->(request) { { example: "proc" }.to_json })
+	logger = ActiveSupport::Logger.new(STDOUT)
+	config.logger = JsonTaggedLogger::Logger.new(logger)
+	# …
+end
+
+```
+
+
+## Why?
+
+On its own, ActiveSupport::TaggedLogging adds individual tags wrapped in squre brackets at the start of each line of log output, like so
+
+```
+[tag1] [tag2] : Foo bar
+```
+
+This is fine as far as it goes, but if you wish to use tagged logging with something like [Lograge](https://github.com/roidrage/lograge) to format your logs as JSON, there's no good way to get the tags into that json output, specially if any of your tags are generated by procs.
+
+## How does it work?
+
+First, JsonTaggedLogger::LogTags helps you generate an array lof log tags suitable for passing to Rails.application.config.log_tags to produce JSON logs. For example, given
+
+```
+Rails.application.config.log_tags = JsonTaggedLogger::LogTags.generate_config(:request_id, :host)
+```
+
+ActiveSupport::TaggedLogging will see the following log tags
+
+```
+[
+  -> (request) { { request_id: request.send(:request_id) }.to_json },
+  -> (request) { { host: request.send(:host) }.to_json }
+]
+```
+
+Why is this an improvement over `Rails.application.config.log_tags = [:request_id, :host]`? Well, with the JsonTaggedLogger version, your logs will now contain
+
+```
+[{"request_id":"c31c3658-5b76-40cd-b583-d0fcbdee0710"}] [{"host":"127.0.0.1"}] log message
+```
+
+which `JsonTaggedLogger::Formatter` will turn into
+
+```json
+{"request_id":"c31c3658-5b76-40cd-b583-d0fcbdee0710","host":"127.0.0.1","msg":"log message"}
+```
+
+Lovely, eh?
+
+The real advantage comes when you have more complicated procs that generage your log tags. So long as your proc produces a JSON string, `JsonTaggedLogger::Formatter` will be able to extract it from the tag and add it to the log hash.
+
+```ruby
+class UserInfoLogTag
+  def self.user_info
+		lambda do |request|
+		  user_info = build_user_info_from_session(request) # build user info from request by inspecting session, etc
+			{ user_info: user_info }.to_json
+		end
+  end
+
+	private
+
+	def self.build_user_info_from_session(request)
+	  # left as an exercise for the reader
+	end
+end
+
+Rails.application.config.log_tags = [ :request_id, :host, UserInfoLogTag.user_info ]
+```
+
+That will get you
+
+```
+{"request_id":"c31c3658-5b76-40cd-b583-d0fcbdee0710","host":"127.0.0.1","user_info":{"user_id":"1234","user_email":"user@example.com"},"msg":"log message"}
+```
+

data/lib/json_tagged_logger/formatter.rb

@@ -0,0 +1,64 @@
+module JsonTaggedLogger
+  class Formatter
+    def call(severity, _time, _progname, message)
+      log = {
+        level: severity,
+      }
+
+      json_tags, text_tags = extract_tags
+
+      json_tags.each { |t| log.merge!(t) }
+
+      if text_tags.present?
+        log[:tags] = text_tags
+      end
+
+      bare_message = message_without_tags(message)
+
+      begin
+        parsed_message = JSON.parse(bare_message)
+      rescue JSON::ParserError
+        parsed_message = bare_message
+      ensure
+        if parsed_message.is_a?(Hash)
+          log.merge!(parsed_message.symbolize_keys)
+        else
+          log.merge!(msg: parsed_message.strip)
+        end
+      end
+
+      log.compact.to_json + "\n"
+    end
+
+    private
+
+    def extract_tags
+      json_tags = Set[]
+      text_tags = Set[]
+
+      current_tags.each do |t|
+        begin
+          tag = JSON.parse(t)
+        rescue JSON::ParserError
+          tag = t
+        ensure
+          if tag.is_a?(Hash)
+            json_tags << tag
+          else
+            text_tags << tag
+          end
+        end
+      end
+
+      [json_tags, text_tags]
+    end
+
+    def message_without_tags(message)
+      if tags_text.present?
+        message.gsub(tags_text.strip, '')
+      else
+        message
+      end
+    end
+  end
+end

data/lib/json_tagged_logger/log_tags_config.rb

@@ -0,0 +1,15 @@
+module JsonTaggedLogger
+  class LogTagsConfig
+    def self.generate(*tags)
+      tags.map do |tag|
+        if tag.is_a?(Proc) && tag.arity == 1
+          tag
+        elsif tag.is_a?(Symbol) && ActionDispatch::Request.method_defined?(tag)
+          -> (request) { { tag => request.send(tag) }.to_json }
+        else
+          raise ArgumentError, "Only symbols that ActionDispatch::Request responds to or single-argument Procs allowed. You provided '#{tag.inspect}'."
+        end
+      end
+    end
+  end
+end

data/lib/json_tagged_logger/logger.rb

@@ -0,0 +1,8 @@
+module JsonTaggedLogger
+  module Logger
+    def self.new(logger)
+      logger.formatter = Formatter.new
+      ActiveSupport::TaggedLogging.new(logger)
+    end
+  end
+end

data/lib/json_tagged_logger/tag_from_session.rb

@@ -0,0 +1,25 @@
+module JsonTaggedLogger
+  module TagFromSession
+    def self.get(key)
+      lambda do |request|
+        { key => get_value_from_session(request, key) }.to_json
+      end
+    end
+
+    private
+
+    def self.get_value_from_session(request, key)
+      session_options = Rails.application.config.session_options
+      session_store = Rails.application.config.session_store.new(Rails.application, session_options)
+      session = ActionDispatch::Request::Session.create(session_store, request, session_options)
+
+      session[key]
+    ensure
+      # Clean up side effects from loading the session so it can be loaded as
+      # usual during the normal request cycle. Leaving these headers in place
+      # seems to break some RSpec specs that interact with the session.
+      request.delete_header("rack.session")
+      request.delete_header("rack.session.options")
+    end
+  end
+end

data/lib/json_tagged_logger/version.rb

@@ -0,0 +1,3 @@
+module JsonTaggedLogger
+  VERSION = "0.1.0"
+end

data/lib/json_tagged_logger.rb

@@ -0,0 +1,4 @@
+require 'json_tagged_logger/formatter'
+require 'json_tagged_logger/log_tags_config'
+require 'json_tagged_logger/logger'
+require 'json_tagged_logger/tag_from_session'

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: json_tagged_logger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sean Santry
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies: []
+description: Formatter for logging with ActiveSupport::TaggedLogging as JSON
+email:
+- sean@santry.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/json_tagged_logger.rb
+- lib/json_tagged_logger/formatter.rb
+- lib/json_tagged_logger/log_tags_config.rb
+- lib/json_tagged_logger/logger.rb
+- lib/json_tagged_logger/tag_from_session.rb
+- lib/json_tagged_logger/version.rb
+homepage: https://github.com/santry/json_tagged_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.20
+signing_key:
+specification_version: 4
+summary: JSON Tagged Log Formatter
+test_files: []