logfmt 0.0.9 → 0.1.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 460da978eb8342c65e74ebbd6cb5f2a37c71efb017c0f1d0a079a32c9e223ff4
-  data.tar.gz: 4b3f4e10f500fa728c459e3b99c68089bb4e3ad85d5ec9c4872d55add8772cf0
+  metadata.gz: d8f2e9e3f3d271e1cad7120cb1fedc6a839050004a51ccd72a9e0ef019b242e6
+  data.tar.gz: 01035abc746fce52ac36c672bec2640a3c4d436f300b244d13b4e936b655030b
 SHA512:
-  metadata.gz: b21d607d999d3275e2f3aedaf0bc11d1f4daa7a51141f2df90367f225c113162f255c457ee854ac78f11fd43a7a9e33e24ef65b72d734bf31c8270dd6e9d3709
-  data.tar.gz: 5535f4b5ce7180c1e0c6263149da57ec8811b14146b92733f4b3f217f41f1fec5eb81bb49b26f62608471f9a9dcad86a0159ca78eec43886570e41b3e18999e8
+  metadata.gz: bb92737ee195acf40cfae4ae48b73895165568690984448e75d9bd4c3a3131f570721ebf0182778c959dc312182f6ebc9bcc0a6a26a877f09e24faa16f2377ff
+  data.tar.gz: 3df2ec4510aad12b18cbe6d1f2da2ffc7b8e3114bb3c66a4b74ae9d04965a5ba766a90db1b7510104295e0c133d36b2bff7190ac80bbbdfac85d770a4b1bb98d

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --format progress
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## \[Unreleased\]
+
+## [0.1.0.beta.1] 2022-10-21
+### Added
+  - Add `Logfmt::Logger` and `Logfmt::TaggedLogger`.
+    The later is distributed as its own gem, `logfmt-tagged_logger`, but lives in this repo.
+
+## [0.0.10] 2022-04-30
+### Changed
+  - Autoload the `Logfmt::Parser` when it's used, in preparation for the coming `Logfmt::Logger` and friends.
+    Alternatively you can eager-load it into memory: `require "logfmt/parser"`.
+
+### Added
+  - This CHANGELOG file.

data/Gemfile

@@ -1,3 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
-gemspec
+gemspec name: "logfmt"
+gemspec name: "logfmt-tagged_logger"

data/README.md

@@ -1,7 +1,154 @@
 # Logfmt
 
-Parse log lines on the logfmt style:
+Write and parse structured log lines in the [logfmt style][logfmt-blog].
 
-    >> require "logfmt"
-    >> Logfmt.parse('foo=bar a=14 baz="hello kitty" cool%story=bro f %^asdf')
-    => {"foo"=>"bar", "a"=>14, "baz"=>"hello kitty", "cool%story"=>"bro", "f"=>true, "%^asdf"=>true}
+## Installation
+
+Add this line to your Gemfile:
+
+```ruby
+gem "logfmt"
+```
+
+And then install:
+
+```bash
+$ bundle
+```
+
+Or install it yourself:
+
+```bash
+$ gem install logfmt
+```
+
+### Versioning
+
+This project adheres to [Semantic Versioning][semver].
+
+## Usage
+
+`Logfmt` is composed to two parts: writing structured log lines in the `logfmt` style, and parsing `logfmt`-style log lines.
+
+While writing and parsing `logfmt` are related, we've found that it's common to only need to do one or there other in a single application.
+To support that usage, `Logfmt` leverages Ruby's `autoload` to lazily load the `Logfmt::Parser` or `Logfmt::Logger` (and associated code) into memory.
+In the general case that looks something like:
+
+```ruby
+require "logfmt"
+
+Logfmt # This constant was already loaded, but neither Logfmt::Parser
+       # nor Logfmt::Logger constants are loaded. Yet.
+
+Logfmt.parse("…")
+  # OR
+Logfmt::Parser.parse("…")
+
+# Either of the above will load the Logfmt::Parser constant.
+# Similarly you can autoload the Logfmt::Logger via
+
+Logfmt::Logger.new
+```
+
+If you want to eagerly load the logger or parser, you can do that by requiring them directly
+
+### Parsing log lines
+
+```ruby
+require "logfmt/parser"
+
+Logfmt::Parser.parse('foo=bar a=14 baz="hello kitty" cool%story=bro f %^asdf')
+  #=> {"foo"=>"bar", "a"=>14, "baz"=>"hello kitty", "cool%story"=>"bro", "f"=>true, "%^asdf"=>true}
+```
+
+### Writing log lines
+
+The `Logfmt::Logger` is built on the stdlib `::Logger` and adheres to its API.
+The primary difference is that `Logfmt::Logger` defaults to a `logfmt`-style formatter.
+Specifically, a `Logfmt::Logger::KeyValueFormatter`, which results in log lines something like this:
+
+```ruby
+require "logfmt/logger"
+
+logger = Logfmt::Logger.new($stdout)
+
+logger.info(foo: "bar", a: 14, "baz" => "hello kitty", "cool%story" => "bro", f: true, "%^asdf" => true)
+  #=> time=2022-04-20T23:30:54.647403Z severity=INFO  foo=bar a=14 baz="hello kitty" cool%story=bro f %^asdf
+
+logger.debug("MADE IT HERE!")
+  #=> time=2022-04-20T23:33:44.912595Z severity=DEBUG msg="MADE IT HERE!"
+```
+
+#### Tagged log lines
+
+The `logfmt-tagged_logger` gem adds support for Rails-style [tagged logging][tagged-logger].
+This gem adds a `Logfmt::TaggedLogger` which is built on `ActiveSupport::TaggedLogger`, but emits the tags in logfmt-style, as key/value pairs.
+For example
+
+```ruby
+logger = Logfmt::TaggedLogger.new($stdout)
+
+logger.tagged(source: "api") do
+  logger.info(foo: "bar")
+end
+
+#=> time=2022-04-20T23:33:44.912595Z severity=info source=api foo=bar"
+```
+
+You can also pass "bare" tags and they'll be collected and emitted under the `tags` key.
+
+```ruby
+logger = Logfmt::TaggedLogger.new($stdout)
+
+logger.tagged("API", "1.2.3.4") do
+  logger.info(foo: "bar")
+end
+
+#=> time=2022-04-20T23:33:44.912595Z severity=info tags="[API] [1.2.3.4]" foo=bar"
+```
+
+It's likely more helpful and useful to use meaningful key/values for your tags, rather than bare tags.
+
+#### Expected key/value transformations
+
+When writing a log line with the `Logfmt::Logger::KeyValueFormatter` the keys and/or values will be transformed thusly:
+
+* "Bare messages" (those with no key given when invoking the logger) will be wrapped in the `msg` key.
+
+    ```ruby
+    logger.info("here")
+      #=> time=2022-04-20T23:33:49.912997Z severity=INFO  msg=here
+    ```
+
+* Values, including bare messages, containing white space or control characters (spaces, tabs, newlines, emoji, etc…) will be wrapped in double quotes (`""`) and fully escaped.
+
+    ```ruby
+    logger.info("👻 Boo!")
+      #=> time=2022-04-20T23:33:35.912595Z severity=INFO  msg="\u{1F47B} Boo!"
+
+    logger.info(number: 42, with_quotes: %{These "are" 'quotes', OK?})
+      #=> time=2022-04-20T23:33:36.412183Z severity=INFO  number=42 with_quotes="These \"are\" 'quotes', OK?"
+    ```
+
+* Floating point values are truncated to three digits.
+
+* Time values are formatted as ISO8601 strings, with six digits sub-second precision.
+
+* A value that is an Array is wrapped in square brackets, and then the above rules applied to each Array value.
+  This works well for arrays of simple values - like numbers, symbols, or simple strings.
+  But complex data structures will result in human mind-breaking escape sequences.
+  So don't do that.
+  Keep values simple.
+
+  ```ruby
+  logger.info(an_array: [1, "two", :three])
+    #=> time=2022-04-20T23:33:36.412183Z severity=INFO  an_array="[1, two, three]"
+  ```
+
+**NOTE**: it is **not** expected that log lines generated by `Logfmt` can be round-tripped by parsing the log line with `Logfmt`.
+Specifically, this applies to Unicode and some control characters, as well as bare messages which will be wrapped in the `msg` key when writing.
+Additionally, symbol keys will be parsed back into string keys.
+
+[logfmt-blog]: https://brandur.org/logfmt "Structured log lines with key/value pairs"
+[semver]: https://semver.org/spec/v2.0.0.html "Semantic Versioning 2.0.0"
+[tagged-logger]: https://guides.rubyonrails.org/debugging_rails_applications.html#tagged-logging "Tagged Logging"

data/Rakefile

@@ -1,6 +1,37 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
+# frozen_string_literal: true
 
+require "bundler/gem_helper"
+require "rspec/core/rake_task"
+
+desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec)
 
+namespace "logfmt" do
+  Bundler::GemHelper.install_tasks name: "logfmt"
+end
+
+# Inspired by how dotenv/dotenv-rails handles mulitple Gems in a single repo
+class LogFmtTaggedLoggerGemHelper < Bundler::GemHelper
+  def guard_already_tagged
+    # noop
+  end
+
+  def tag_version
+    # noop
+  end
+end
+
+namespace "logfmt-tagged_logger" do
+  LogFmtTaggedLoggerGemHelper.install_tasks name: "logfmt-tagged_logger"
+end
+
+desc "Build logfmt and logfmt-tagged_logger into the pkg directory"
+task build: ["logfmt:build", "logfmt-tagged_logger:build"]
+
+desc "Build and install logfmt and logfmt-tagged_logger into system gems"
+task install: ["logfmt:install", "logfmt-tagged_logger:install"]
+
+desc "Create tag, build, and push logfmt and logfmt-tagged_logger to rubygems.org"
+task release: ["logfmt:release", "logfmt-tagged_logger:release"]
+
 task default: :spec

data/bench.rb

@@ -1,13 +1,15 @@
-$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
 
-require 'benchmark'
-require 'logfmt'
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require "benchmark"
+require "logfmt"
 
 N = 1_000
 line = 'foo=bar a=14 baz="hello kitty" ƒ=2h3s cool%story=bro f %^asdf'
 
 Benchmark.bm(20) do |x|
-  x.report('char-by-char') do
+  x.report("char-by-char") do
     N.times do
       Logfmt.parse(line)
     end

data/lib/logfmt/logger.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../logfmt"
+require "logger"
+require "time"
+
+module Logfmt
+  class Logger < ::Logger
+    def initialize(*args, **kwargs)
+      super
+      @formatter ||= KeyValueFormatter.new
+    end
+
+    class KeyValueFormatter < ::Logger::Formatter
+      def call(severity, timestamp, progname, msg)
+        %(time=#{format_datetime(timestamp)} severity=#{severity.ljust(5)}#{format_progname(progname)} #{format_message(msg)}\n)
+      end
+
+      private
+
+      def format_datetime(time)
+        time.utc.iso8601(6)
+      end
+
+      def format_message(msg)
+        return unless msg
+
+        if msg.respond_to?(:to_hash)
+          pairs = msg.to_hash.map { |k, v| format_pair(k, v) }
+          pairs.compact.join(" ")
+        else
+          format_pair("msg", msg)
+        end
+      end
+
+      def format_pair(key, value)
+        return nil if value.nil?
+
+        # Return a bare key when the value is a `TrueClass`
+        return key if value == true
+
+        "#{key}=#{format_value(value)}"
+      end
+
+      def format_progname(progname)
+        return nil unless progname
+
+        # Format this pair like any other to ensure quoting, escaping, etc…,
+        # But we also need a leading space so we can interpolate the resulting
+        # key/value pair into our log line.
+        " #{format_pair(" progname", progname)}"
+      end
+
+      def format_value(value)
+        if value.is_a?(Float)
+          format("%.3f", value)
+        elsif value.is_a?(Time)
+          format_datetime(value)
+        elsif value.respond_to?(:to_ary)
+          format_value(
+            "[#{Array(value).map { |v| format_value(v) }.join(", ")}]"
+          )
+        else
+          # Interpolating due to a weird/subtle behaviour possible in #to_s.
+          # Namely, it's possible it doesn't actually return a String:
+          # https://github.com/ruby/spec/blob/3affe1e54fcd11918a242ad5d4a7ba895ee30c4c/language/string_spec.rb#L130-L141
+          value = "#{value}" # rubocop:disable Style/RedundantInterpolation
+          value = value.dump if value.match?(/[[:space:]]|[[:cntrl:]]/) # wrap in quotes and escape control characters
+          value
+        end
+      end
+    end
+  end
+end

data/lib/logfmt/parser.rb

@@ -1,112 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "../logfmt"
+
 module Logfmt
-  GARBAGE = 0
-  KEY = 1
-  EQUAL = 2
-  IVALUE = 3
-  QVALUE = 4
+  module Parser
+    GARBAGE = 0
+    KEY = 1
+    EQUAL = 2
+    IVALUE = 3
+    QVALUE = 4
 
-  def self.numeric?(s)
-    s.is_a?(Numeric) || s.to_s.match(/\A[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\Z/)
-  end
+    def self.numeric?(s)
+      s.is_a?(Numeric) || s.to_s.match?(/\A[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\Z/)
+    end
 
-  def self.integer?(s)
-    s.is_a?(Integer) || s.to_s.match(/\A[-+]?[0-9]+\Z/)
-  end
+    def self.integer?(s)
+      s.is_a?(Integer) || s.to_s.match?(/\A[-+]?[0-9]+\Z/)
+    end
 
-  def self.parse(line)
-    output = {}
-    key, value = '', ''
-    escaped = false
-    state = GARBAGE
-    i = 0
-    line.each_char do |c|
-      i += 1
-      if state == GARBAGE
-        if c > ' ' && c != '"' && c != '='
-          key = c
-          state = KEY
-        end
-        next
-      end
-      if state == KEY
-        if c > ' ' && c != '"' && c != '='
-          state = KEY
-          key << c
-        elsif c == '='
-          output[key.strip] = true
-          state = EQUAL
-        else
-          output[key.strip] = true
-          state = GARBAGE
-        end
-        output[key.strip] = true if i >= line.length
-        next
-      end
-      if state == EQUAL
-        if c > ' ' && c != '"' && c != '='
-          value = c
-          state = IVALUE
-        elsif c == '"'
-          value = ''
-          escaped = false
-          state = QVALUE
-        else
-          state = GARBAGE
+    def self.parse(line)
+      output = {}
+      key, value = +"", +""
+      escaped = false
+      state = GARBAGE
+      i = 0
+      line.each_char do |c|
+        i += 1
+        if state == GARBAGE
+          if c > " " && c != '"' && c != "="
+            key = c
+            state = KEY
+          end
+          next
         end
-        if i >= line.length
-          if integer?(value)
-            value = value.to_i
-          elsif numeric?(value)
-            fvalue = value.to_f
-            value = fvalue if fvalue.finite?
+        if state == KEY
+          if c > " " && c != '"' && c != "="
+            state = KEY
+            key << c
+          elsif c == "="
+            output[key.strip] = true
+            state = EQUAL
+          else
+            output[key.strip] = true
+            state = GARBAGE
           end
-          output[key.strip] = value || true
+          output[key.strip] = true if i >= line.length
+          next
         end
-        next
-      end
-      if state == IVALUE
-        if !(c > ' ' && c != '"')
-          if integer?(value)
-            value = value.to_i
-          elsif numeric?(value)
-            fvalue = value.to_f
-            value = fvalue if fvalue.finite?
+        if state == EQUAL
+          if c > " " && c != '"' && c != "="
+            value = c
+            state = IVALUE
+          elsif c == '"'
+            value = +""
+            escaped = false
+            state = QVALUE
+          else
+            state = GARBAGE
+          end
+          if i >= line.length
+            if integer?(value)
+              value = value.to_i
+            elsif numeric?(value)
+              fvalue = value.to_f
+              value = fvalue if fvalue.finite?
+            end
+            output[key.strip] = value || true
           end
-          output[key.strip] = value
-          state = GARBAGE
-        else
-          value << c
+          next
         end
-        if i >= line.length
-          if integer?(value)
-            value = value.to_i
-          elsif numeric?(value)
-            fvalue = value.to_f
-            value = fvalue if fvalue.finite?
+        if state == IVALUE
+          if !(c > " " && c != '"')
+            if integer?(value)
+              value = value.to_i
+            elsif numeric?(value)
+              fvalue = value.to_f
+              value = fvalue if fvalue.finite?
+            end
+            output[key.strip] = value
+            state = GARBAGE
+          else
+            value << c
           end
-          output[key.strip] = value
+          if i >= line.length
+            if integer?(value)
+              value = value.to_i
+            elsif numeric?(value)
+              fvalue = value.to_f
+              value = fvalue if fvalue.finite?
+            end
+            output[key.strip] = value
+          end
+          next
         end
-        next
-      end
-      if state == QVALUE
-        if c == '\\'
-          escaped = true
-          value << '\\'
-        elsif c == '"'
-          if escaped
+        if state == QVALUE
+          if c == "\\"
+            escaped = true
+            value << "\\"
+          elsif c == '"'
+            if escaped
+              escaped = false
+              value.chop! << c
+              next
+            end
+            output[key.strip] = value
+            state = GARBAGE
+          else
             escaped = false
-            value.chop! << c
-            next
+            value << c
           end
-          output[key.strip] = value
-          state = GARBAGE
-        else
-          escaped = false
-          value << c
+          next
         end
-        next
       end
+      output
     end
-    output
   end
 end

data/lib/logfmt/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Logfmt
-  VERSION = '0.0.9'
+  VERSION = "0.1.0.beta.1"
 end

data/lib/logfmt.rb

@@ -1,2 +1,12 @@
-require 'logfmt/version'
-require 'logfmt/parser'
+# frozen_string_literal: true
+
+require "logfmt/version"
+
+module Logfmt
+  autoload(:Logger, "logfmt/logger")
+  autoload(:Parser, "logfmt/parser")
+
+  def self.parse(line)
+    const_get(:Parser).parse(line)
+  end
+end

data/logfmt.gemspec

@@ -1,22 +1,40 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'logfmt/version'
+# frozen_string_literal: true
 
-Gem::Specification.new do |gem|
-  gem.name          = 'logfmt'
-  gem.version       = Logfmt::VERSION
-  gem.authors       = ['Timothée Peignier']
-  gem.email         = ['timothee.peignier@tryphon.org']
-  gem.description   = %q{Parse log lines in the logfmt style.}
-  gem.summary       = %q{Parse logfmt messages.}
-  gem.homepage      = 'https://github.com/cyberdelia/logfmt-ruby'
-  gem.license       = 'MIT'
+require_relative "lib/logfmt/version"
+require "English"
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ['lib']
-  gem.add_development_dependency 'rspec', '~> 3.0'
-  gem.add_development_dependency 'rake', '~> 10.3'
+Gem::Specification.new do |spec|
+  spec.name = "logfmt"
+  spec.version = Logfmt::VERSION
+  spec.authors = ["Timothée Peignier"]
+  spec.email = ["timothee.peignier@tryphon.org"]
+
+  spec.summary = "Write and parse logfmt messages."
+  spec.description = "Write and parse log lines in the logfmt style."
+  spec.homepage = "https://github.com/cyberdelia/logfmt-ruby"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.5.0"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "#{spec.homepage}/issues",
+    "changelog_uri" => "#{spec.homepage}/blog/master/CHANGELOG.md",
+    "documentation_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage
+  }
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+      .reject { |f|
+        (f == __FILE__) ||
+          f.match?(%r{\A(?:(?:bin|spec|features)/|\.(?:git|github))}) ||
+          f.match?(/tagged_logger/)
+      }
+  end
+  spec.bindir = "bin"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "pry-byebug", "~> 3.9"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
 end

metadata

@@ -1,68 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: logfmt
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0.beta.1
 platform: ruby
 authors:
 - Timothée Peignier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-30 00:00:00.000000000 Z
+date: 2022-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.3'
+        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.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.3'
-description: Parse log lines in the logfmt style.
+        version: '3.0'
+description: Write and parse log lines in the logfmt style.
 email:
 - timothee.peignier@tryphon.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/gempush.yml"
-- ".github/workflows/ruby.yml"
-- ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - bench.rb
 - lib/logfmt.rb
+- lib/logfmt/logger.rb
 - lib/logfmt/parser.rb
 - lib/logfmt/version.rb
 - logfmt.gemspec
-- spec/logfmt/parser_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/cyberdelia/logfmt-ruby
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/cyberdelia/logfmt-ruby/issues
+  changelog_uri: https://github.com/cyberdelia/logfmt-ruby/blog/master/CHANGELOG.md
+  documentation_uri: https://github.com/cyberdelia/logfmt-ruby
+  source_code_uri: https://github.com/cyberdelia/logfmt-ruby
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -71,17 +86,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
-summary: Parse logfmt messages.
-test_files:
-- spec/logfmt/parser_spec.rb
-- spec/spec_helper.rb
+summary: Write and parse logfmt messages.
+test_files: []

data/.github/workflows/gempush.yml

@@ -1,24 +0,0 @@
-name: Publish
-on:
-  release:
-    types: [created]
-jobs:
-  build:
-    name: Build + Publish
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@master
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
-      with:
-        version: 2.6.x
-    - name: Publish to RubyGems
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push *.gem
-      env:
-        GEM_HOST_API_KEY: ${{secrets.RUBYGEMS_AUTH_TOKEN}}

data/.github/workflows/ruby.yml

@@ -1,19 +0,0 @@
-name: CI
-on: [push]
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby: [ '2.4', '2.5', '2.6' ]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Set up Ruby
-      uses: actions/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-    - name: Run tests
-      run: |
-        gem install bundler
-        bundle install --jobs 4 --retry 3
-        bundle exec rspec spec

data/.gitignore

@@ -1,19 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-.ruby-version
-.tags

data/spec/logfmt/parser_spec.rb

@@ -1,159 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'logfmt/parser'
-
-describe Logfmt do
-  it 'parse empty log line' do
-    data = Logfmt.parse('')
-    expect(data).to eq({})
-  end
-
-  it 'parse whitespace only log line' do
-    data = Logfmt.parse("\t")
-    expect(data).to eq({})
-  end
-
-  it 'parse key without value' do
-    data = Logfmt.parse('key')
-    expect(data).to eq('key' => true)
-  end
-
-  it 'parse key without value and whitespace' do
-    data = Logfmt.parse('  key  ')
-    expect(data).to eq('key' => true)
-  end
-
-  it 'parse multiple single keys' do
-    data = Logfmt.parse('key1 key2')
-    expect(data).to eq('key1' => true, 'key2' => true)
-  end
-
-  it 'parse unquoted value' do
-    data = Logfmt.parse('key=value')
-    expect(data).to eq('key' => 'value')
-  end
-
-  it 'parse pairs' do
-    data = Logfmt.parse('key1=value1 key2=value2')
-    expect(data).to eq('key1' => 'value1', 'key2' => 'value2')
-  end
-
-  it 'parse mixed single/non-single pairs' do
-    data = Logfmt.parse('key1=value1 key2')
-    expect(data).to eq('key1' => 'value1', 'key2' => true)
-  end
-
-  it 'parse mixed pairs whatever the order' do
-    data = Logfmt.parse('key1 key2=value2')
-    expect(data).to eq('key1' => true, 'key2' => 'value2')
-  end
-
-  it 'parse quoted value' do
-    data = Logfmt.parse('key="quoted value"')
-    expect(data).to eq('key' => 'quoted value')
-  end
-
-  it 'parse escaped quote value ' do
-    data = Logfmt.parse('key="quoted \" value" r="esc\t"')
-    expect(data).to eq('key' => 'quoted " value', 'r' => 'esc\t')
-  end
-
-  it 'parse mixed pairs' do
-    data = Logfmt.parse('key1="quoted \" value" key2 key3=value3')
-    expect(data).to eq('key1' => 'quoted " value', 'key2' => true, 'key3' => 'value3')
-  end
-
-  it 'parse mixed characters pairs' do
-    data = Logfmt.parse('foo=bar a=14 baz="hello kitty" ƒ=2h3s cool%story=bro f %^asdf')
-    expect(data).to eq('foo' => 'bar', 'a' => 14, 'baz' => 'hello kitty',
-      'ƒ' => '2h3s', 'cool%story' => 'bro', 'f' => true, '%^asdf' => true)
-  end
-
-  it 'parse pair with empty quote' do
-    data = Logfmt.parse('key=""')
-    expect(data).to eq('key' => '')
-  end
-
-  # Currently, the value comes back as "true", which could mess up stats
-  # Really, only "true" should come back as "true"
-  # it 'parse 1 as integer type' do
-  #   data = Logfmt.parse('key=1')
-  #   expect(data['key'].class).to eq(Fixnum)
-  # end
-
-  it 'parse positive integer as integer type' do
-    data = Logfmt.parse('key=234')
-    expect(data['key']).to eq(234)
-    expect(data['key'].class).to eq(Fixnum)
-  end
-
-  it 'parse negative integer as integer type' do
-    data = Logfmt.parse('key=-3428')
-    expect(data['key']).to eq(-3428)
-    expect(data['key'].class).to eq(Fixnum)
-  end
-
-  it 'parse positive float as float type' do
-    data = Logfmt.parse('key=3.342')
-    expect(data['key']).to eq(3.342)
-    expect(data['key'].class).to eq(Float)
-  end
-
-  it 'parse negative float as float type' do
-    data = Logfmt.parse('key=-0.9934')
-    expect(data['key']).to eq(-0.9934)
-    expect(data['key'].class).to eq(Float)
-  end
-
-  it 'parse exponential float as float type' do
-    data = Logfmt.parse('key=2.342342342342344e+18')
-    expect(data['key']).to eq(2.342342342342344e+18)
-    expect(data['key'].class).to eq(Float)
-  end
-
-  it 'parse long digit string with embedded e as string' do
-    data = Logfmt.parse('key=2342342342342344e1818')
-    expect(data['key'].class).to eq(String)
-  end
-
-  it 'parse quoted integer as string type' do
-    data = Logfmt.parse('key="234"')
-    expect(data['key'].class).to eq(String)
-  end
-
-  it 'parse quoted float as string type' do
-    data = Logfmt.parse('key="3.14"')
-    expect(data['key'].class).to eq(String)
-  end
-
-  it 'parse IP address as string type' do
-    data = Logfmt.parse('key=10.10.10.1')
-    expect(data['key'].class).to eq(String)
-  end
-
-  it 'parse last as integer type' do
-    data = Logfmt.parse('key1=4 key2=9')
-    expect(data['key1']).to eq(4)
-    expect(data['key2']).to eq(9)
-  end
-
-  it 'parse string containing quotes' do
-    data = Logfmt.parse('key1="{\"msg\": \"hello\tworld\"}"')
-    expect(data['key1']).to eq('{"msg": "hello\tworld"}')
-  end
-
-  it 'parse value containing equal sign' do
-    query = 'position=44.80450799126121%2C33.58320759981871&uid=1'
-    data = Logfmt.parse("method=GET query=#{query} status=200")
-    expect(data).to eq(
-      'method' => 'GET',
-      'query' => query,
-      'status' => 200
-    )
-  end
-
-  it 'parses integers correctly' do
-    data = Logfmt.parse('key=111 ')
-    expect(data['key']).to eq(111)
-  end
-end

data/spec/spec_helper.rb

@@ -1,16 +0,0 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-end