milemarker 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1cc6c3aa16cc1d24991354663de1ceea5859d82a025e83d2683b9fa3b49d5f9e
+  data.tar.gz: 924edbc92d18fd924d4934f188a88e9c36ed8bbbae443a7815462b4d40388fe0
+SHA512:
+  metadata.gz: 7841d99693517311d47206ca49890278386643130dd934b6ca6f93fa0b0032c5e6f8aaaf038f8c0336ff2e967744d0e86a86c7dcb9b34e8030cdcecaf97a5773
+  data.tar.gz: 033d5566f4d893668c03f358f40a8ee2d0bd26610010e05ca11871225b94c2288f3bd252c1e9fc05f75034f200ba43d28520be5eba5d715e6f63766f8b19e765

data/.github/workflows/main.yml

@@ -0,0 +1,16 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.6.6
+        bundler-cache: true
+    - name: Run the default task
+      run: bundle exec rake

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops: 
+  TargetRubyVersion: 2.7
+
+Style/StringLiterals:
+  Enabled: false
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## [1.0.0] - 2021-11-29
+
+First public release
+

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in milemarker.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Bill Dueber
+
+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,209 @@
+# Milemarker -- track (and probably log) progress in batch jobs
+
+Never again write code of the
+form `log.info "Finished 1_000 in #{secs} seconds at a rate of #{total.to_f / secs}"`
+.
+
+## Usage
+
+```ruby
+
+require 'milemarker'
+require 'logger'
+input_file = "records.ndj"
+
+# Create a new milemarker. Default batch_size is 1_000
+milemarker     = Milemarker.new(name: "Load #{input_file}", batch_size: 1_000_000)
+logger = Logger.new(STDERR)
+
+milemarker.logger = logger
+
+File.open(input_file).each do |line|
+  do_whatever_needs_doing(line)
+  milemarker.increment_and_log_batch_line
+end
+milemarker.log_final_line # if logging is set up
+
+# Identical to the above, but do the logging "by hand"
+File.open(input_file).each do |line|
+  do_whatever_needs_doing(line)
+  milemarker.increment_and_on_batch { logger.info milemarker.batch_line }
+end
+logger.info milemarker.final_line
+
+# Sample output
+# ...
+# I, [2021-11-02T01:51:06.959137 #11710]  INFO -- : load records.ndj   8_000_000. This batch 2_000_000 in 26.2s (76_469 r/s). Overall 72_705 r/s.
+# I, [2021-11-02T01:51:36.992831 #11710]  INFO -- : load records.ndj  10_000_000. This batch 2_000_000 in 30.0s (66_591 r/s). Overall 71_394 r/s.
+# ...
+# I, [2021-11-02T02:01:56.702196 #11710]  INFO -- : load records.ndj FINISHED. 27_138_118 total records in 00h 12m 39s. Overall 35_718 r/s.
+
+```
+
+## Basic usage
+
+Most programs will probably use `milemarker` is via
+`#increment_and_log_batch_line`
+(or its counterpart `#increment_and_on_batch {|milemarker| ... }` ). As 
+the name suggests, this will:
+
+* increment the batch counter
+* If the batch counter >= the batch size:
+  * run the provided block (or write the logline)
+  * reset count/time/etc for the next batch
+
+Some examples:
+
+```ruby
+
+# Logging, as above
+milemarker = Milemarker.new(batch_size: 1000, name: 'Load myfile')
+milemarker.increment_and_on_batch { logger.info milemarker.batch_line }
+
+# Alert when things seem to to take too long
+
+milemarker.increment_and_on_batch do |milemarker|
+  secs = milemarker.last_batch_seconds
+  if secs > way_too_long
+    logger.error "Whoa: #{secs} is too long for a batch of #{milemarker.batch_size}"
+  end
+end
+
+# #on_batch and #increment_and_on_batch can be used to do real (i.e., 
+# non-logging) work after every `batch` calls, too
+queue = []
+my_stuff.each do |doc|
+  queue << do_something_to(doc)
+  milemarker.increment_and_on_batch do |milemarker|
+    write_to_datastore(queue)
+    queue = []
+    logger.info milemarker.batch_line
+  end
+end
+```
+
+`#incr` and `#on_batch(&blk)` are also available separately if you need to be
+more explicit and less atomic.
+
+All the components that make up a batch_line (e.g., the records/second as 
+a nice string) are available to roll your own batch line. See the API 
+documentation for details. 
+
+### Incorporating a logger into milemarker
+
+For standard logging cases, you can also pass in a logger, or let milemarker
+create one for its own use based on an IO-like object you provide
+
+```ruby
+logger = Logger.new(STDERR)
+milemarker     = Milemarker.new(name: 'my_process', batch_size: 10_000, logger: logger)
+
+# same thing
+milemarker        = Milemarker.new(name: 'my_process', batch_size: 10_000)
+milemarker.logger = logger
+
+# same thing again
+milemarker = Milemarker.new(name: 'my_process', batch_size: 10_000)
+milemarker.create_logger!(STDERR)
+
+File.open(input_file).each do |line|
+  do_whatever_needs_doing(line)
+  milemarker.increment_and_log_batch_line
+end
+
+milemarker.log_final_line
+
+# All the logging methods take an optional :level argument
+milemarker.log_final_line(level: :debug)
+
+```
+
+### Structured logging with Milemarker::Structured
+
+`Milemarker::Structured` will return hashes for `#batch_line` and `#final_line`
+(aliased to `#batch_data` and `#final_data`, respectively) and pass those
+hashes along to whatever logger you provide. `#create_logger!` for this
+subclass will create a logger that provides json lines instead of text, too.
+
+Presumably, if you pass in your own logger you'll use something like
+[semantic_logger](https://github.com/reidmorrison/semantic_logger)
+or [ougai](https://github.com/tilfin/ougai).
+
+```ruby
+milemarker = Milemarker::Structured.new(name: 'my_process', batch_size: 10_000)
+milemarker.create_logger!(STDERR)
+
+File.open(input_file).each do |line|
+  do_whatever_needs_doing(line)
+  milemarker.increment_and_log_batch_line
+end
+
+# Usually one line; broken up for readability
+# {"name":"my_process","batch_count":10_000,"batch_seconds":97.502088,
+# "batch_rate":1.035875252230496,"total_count":100,"total_seconds":97.502094,
+# "total_rate":1.0358751884856956,"level":"INFO","time":"2021-11-06 17:32:21 -0400"}
+
+```
+
+## Threadsafety
+
+A call to `milemaker.threadsafify!` will wrap `increment_and_on_batch` (and
+`increment_and_log_batch_line`) to be a threadsafe atomic operation at the 
+cost of some performance. 
+
+```
+milemarker.threadsafify!
+
+```
+
+## Turning off logging
+
+If the logger is set to `nil`, no logging will occur.
+
+```ruby
+# Turn off logging
+
+milemarker.logger = nil
+```
+
+You could also just configure your logger to ignore stuff
+
+```ruby
+
+milemarker.logger.level = :error
+
+```
+
+## Accuracy
+
+Note that `milemarker` isn't designed for real benchmarking. The assumption is
+that whatever work your code is actually doing will drown out any
+inefficiencies in the `milemarker` code, and milemarker numbers can be used to suss out 
+where weird things are happening. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'milemarker'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install milemarker
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub
+at https://github.com/billdueber/milemarker.
+
+## License
+
+The gem is available as open source under the terms of
+the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "waypoint"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/milemarker/structured.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class Milemarker
+  # Milemarker for structured logging
+  #   * #create_logger! creates a logger that spits out JSON lines instead of human-centered strings
+  #   * #batch_line and #final_line return hashes of count/time/rate data
+  #     *...and are aliased to #batch_data and #final_data
+  #
+  # Milemarker::Structured should be a drop-in replacement for Milemarker, with the above differences
+  # and of course the caveat that if you provide your own logger it should expect to deal with
+  # the hashes coming from #batch_data and #final_data
+  class Structured < Milemarker
+    # Create a logger that spits out JSON strings instead of human-oriented strings'
+    # In addition to whatever message is passed, will always also include
+    # { level: severity, time: datetime }
+    #
+    # The logger will try to deal intelligently with different types of arguments
+    #   * a Hash will just be passed
+    #   * a String;s return json will show up in the hash under the key 'msg'
+    #   * an Exception's return json will have the error's message, class, the first bit of the backtrace, and hostname
+    #   * Anything else will be treated like a hash if it responds to #to_h;
+    #     otherwise use msg.inspect as a message string
+    def create_logger!(*args, **kwargs)
+      super
+      @logger.formatter = proc do |severity, datetime, _progname, msg|
+        case msg
+        when Hash
+          msg
+        when String
+          { msg: msg }
+        when Exception
+          exception_message_hash(msg)
+        else
+          other_message_hash(msg)
+        end.merge({ level: severity, time: datetime }).to_json
+      end
+      self
+    end
+
+    # @return [Hash] hash with information about the last batch
+    def batch_line
+      {
+        name: name,
+        batch_count: last_batch_size,
+        batch_seconds: last_batch_seconds,
+        batch_rate: batch_rate,
+        total_count: count,
+        total_seconds: total_seconds_so_far,
+        total_rate: total_rate
+      }
+    end
+
+    alias batch_data batch_line
+
+    # @return [Hash] hash with information about the last batch
+    def final_line
+      {
+        name: name,
+        final_batch_size: final_batch_size,
+        total_count: count,
+        total_seconds: total_seconds_so_far,
+        total_rate: total_rate
+      }
+    end
+
+    alias final_data final_line
+
+    def exception_message_hash(msg)
+      { msg: msg.message, error: msg.class, at: msg.backtrace&.first, hostname: Socket.gethostname }
+    end
+
+    def other_message_hash(msg)
+      if msg.respond_to? :to_h
+        msg.to_h
+      else
+        { msg: msg.inspect }
+      end
+    end
+  end
+end

data/lib/milemarker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Milemarker
+  VERSION = "1.0.0"
+end

data/lib/milemarker.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require_relative "ppnum"
+require 'logger'
+require 'socket'
+require 'json'
+require 'milemarker/structured'
+
+# milemarker class, to keep track of progress over time for long-running
+# iterating processes
+#
+# @author Bill Dueber <bill@dueber.com>
+class Milemarker
+  # @return [String] optional "name" of this milemarker, for logging purposes
+  attr_accessor :name
+
+  # @return [Integer] batch size for computing `on_batch` calls
+  attr_accessor :batch_size
+
+  # @return [Logger, #info] logging object for automatic logging methods
+  attr_accessor :logger
+
+  # @return [Integer] which batch number (total increment / batch_size)
+  attr_reader :batch_number
+
+  # @return [Integer] number of second to process the last batch
+  attr_reader :last_batch_seconds
+
+  # @return [Integer] number of records (really, number of increments) in the last batch
+  attr_reader :last_batch_size
+
+  # @return [Time] Time the full process started
+  attr_reader :start_time
+
+  # @return [Time] Time the last batch started processing
+  attr_reader :batch_start_time
+
+  # @return [Time] Time the last batch ended processing
+  attr_reader :batch_end_time
+
+  # @return [Integer] Total records (really, increments) for the full run
+  attr_reader :count
+
+  # @return [Integer] Total count at the time of the last on_batch call. Used to figure out
+  #   how many records were in the final batch
+  attr_reader :prev_count
+
+  # Create a new milemarker tracker, with an optional name and logger
+  # @param [Integer] batch_size How often the on_batch block will be called
+  # @param [String] name Optional "name" for this milemarker, included in the generated log lines
+  # @param [Logger, #info, #warn] Optional logger that responds to the normal #info, #warn, etc.
+  def initialize(batch_size: 1000, name: nil, logger: nil)
+    @batch_size = batch_size
+    @name       = name
+    @logger     = logger
+
+    @batch_number = 0
+    @last_batch_size    = 0
+    @last_batch_seconds = 0
+
+    @start_time       = Time.now
+    @batch_start_time = @start_time
+    @batch_end_time   = @start_time
+
+    @count      = 0
+    @prev_count = 0
+  end
+
+  # Turn `increment_and_batch` (and thus `increment_and_log_batch_line`) into
+  # a threadsafe version
+  # @return [Milemarker] self
+  def threadsafify!
+    @mutex = Mutex.new
+    define_singleton_method(:increment_and_on_batch) do |&blk|
+      threadsafe_increment_and_on_batch(&blk)
+    end
+    self
+  end
+
+  # Increment the counter -- how many records processed, e.g.
+  # @return [Milemarker] self
+  def incr(increase = 1)
+    @count += increase
+    self
+  end
+
+  alias increment incr
+
+  # Create a logger for use in logging milemaker information
+  # @example mm.create_logger!(STDOUT)
+  # @return [Milemarker] self
+  def create_logger!(*args, **kwargs)
+    @logger = Logger.new(*args, **kwargs)
+    self
+  end
+
+  # Run the given block if we've exceeded the batch size for the current batch
+  # @yield [Milemarker] self
+  def on_batch
+    if batch_size_exceeded?
+      set_milemarker!
+      yield self
+    end
+  end
+
+  # Single call to increment and run (if needed) the on_batch block
+  def _increment_and_on_batch(&blk)
+    incr.on_batch(&blk)
+  end
+
+  alias increment_and_on_batch _increment_and_on_batch
+
+  # Threadsafe version of #increment_and_on_batch, doing the whole thing as a single atomic action
+  def threadsafe_increment_and_on_batch(&blk)
+    @mutex.synchronize do
+      _increment_and_on_batch(&blk)
+    end
+  end
+
+  # Convenience method, exactly the same as the common idiom
+  #   `mm.incr; mm.on_batch {|mm| log.info mm.batch_line}`
+  # @param [Symbol] level The level to log at
+  def increment_and_log_batch_line(level: :info)
+    increment_and_on_batch { log_batch_line(level: level) }
+  end
+
+  # Log the batch line, as described in #batch_line
+  # @param [Symbol] level The level to log at
+  def log_batch_line(level: :info)
+    log(batch_line, level: level)
+  end
+
+  # Log the final line, as described in #final_line
+  # @param [Symbol] level The level to log at
+  def log_final_line(level: :info)
+    log(final_line, level: level)
+  end
+
+  # A line describing the batch suitable for logging, of the form
+  #   load records.ndj   8_000_000. This batch 2_000_000 in 26.2s (76_469 r/s). Overall 72_705 r/s.
+  # @return [String] The batch log line
+  def batch_line
+    # rubocop:disable Layout/LineLength
+    "#{name} #{ppnum(count, 10)}. This batch #{ppnum(last_batch_size, 5)} in #{ppnum(last_batch_seconds, 4, 1)}s (#{batch_rate_str} r/s). Overall #{total_rate_str} r/s."
+    # rubocop:enable Layout/LineLength
+  end
+
+  # Record how many increments there have been since the last on_batch call.
+  # Most useful to count how many items are in the final (usually incomplete) batch
+  # Note that since Milemarker can't tell when you're done processing, you can call this
+  # anytime and get the number of items processed since the last on_batch call.
+  # @return [Integer] Number of items processed in the final batch
+  def final_batch_size
+    count - prev_count
+  end
+
+  alias batch_count_so_far final_batch_size
+
+  # A line describing the entire run, suitable for logging, of the form
+  #   load records.ndj FINISHED. 27_138_118 total records in 00h 12m 39s. Overall 35_718 r/s.
+  # @return [String] The full log line
+  def final_line
+    # rubocop:disable Layout/LineLength
+    "#{name} FINISHED. #{ppnum(count, 10)} total records in #{seconds_to_time_string(total_seconds_so_far)}. Overall #{total_rate_str} r/s."
+    # rubocop:enable Layout/LineLength
+  end
+
+  # @return [Float] rate of the last batch (in recs/second)
+  def batch_rate
+    return 0.0 if count.zero?
+
+    last_batch_size.to_f / last_batch_seconds
+  end
+
+  # @param [Integer] decimals Number of decimal places to the right of the
+  #   decimal point
+  # @return [String] Rate-per-second in form XXX.YY
+  def batch_rate_str(decimals = 0)
+    ppnum(batch_rate, 0, decimals)
+  end
+
+  # @return [Float] total rate so far (in rec/second)
+  def total_rate
+    return 0.0 if @count.zero?
+
+    count / total_seconds_so_far
+  end
+
+  # @param [Integer] decimals Number of decimal places to the right of the
+  #   decimal point
+  # @return [String] Rate-per-second in form XXX.YY
+  def total_rate_str(decimals = 0)
+    ppnum(total_rate, 0, decimals)
+  end
+
+  # Total seconds since the beginning of this milemarker
+  # @return [Float] seconds since the milemarker was created
+  def total_seconds_so_far
+    Time.now - start_time
+  end
+
+  # Total seconds since this batch started
+  # @return [Float] seconds since the beginning of this batch
+  def batch_seconds_so_far
+    Time.now - batch_start_time
+  end
+
+  # Set/reset all the internal state. Called by #on_batch when necessary;
+  # should probably not be called manually
+  def set_milemarker!
+    @batch_end_time     = Time.now
+    @last_batch_size    = @count - @prev_count
+    @last_batch_seconds = @batch_end_time - @batch_start_time
+
+    reset_for_next_batch!
+  end
+
+  # Reset the internal counters/timers at the end of a batch. Taken care of
+  # by #on_batch; should probably not be called manually.
+  def reset_for_next_batch!
+    @batch_start_time  = batch_end_time
+    @prev_count        = count
+    @batch_number = batch_divisor
+  end
+
+  # Log a line using the internal logger. Do nothing if no logger is configured.
+  # @param [String] msg The message to log
+  # @param [Symbol] level The level to log at
+  def log(msg, level: :info)
+    logger&.send(level, msg)
+  end
+
+  private
+
+  def batch_size_exceeded?
+    batch_divisor > @batch_number
+  end
+
+  def batch_divisor
+    count.div batch_size
+  end
+
+  def seconds_to_time_string(sec)
+    hours, leftover = sec.divmod(3600)
+    minutes, secs   = leftover.divmod(60)
+    format("%02dh %02dm %02ds", hours, minutes, secs)
+  end
+end

data/lib/ppnum.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# WHAT? Defining a global function? Yup.
+#
+# "Pretty print" a number into an underscore-delimited numeric string,
+# right-space-padded out to the specified width (default 0 indicating
+# "no padding") and with the specified number of digits to the right
+# of the decimal point (default again 0, meaning no decimal point at all)
+#
+# Example: ppnum(10111) => "10_111"
+#          ppnum(1234.56) => 1_235
+#          ppnum(10111.3656, 10, 1) => "  10_111.4"
+#
+# No attempt is made to deal gracefully with numbers that overrun the
+# specified width
+# @param [Numeric] num the number to format
+# @param [Integer] width The width to target
+# @param [Integer] decimals Number of decimal places to show
+# @return [String] The formatted number
+def ppnum(num, width = 0, decimals = 0)
+  num = num.round(decimals)
+  dec_str = if decimals.zero?
+              ""
+            else
+              ".#{format("%.#{decimals}f", num).split(".").last}"
+            end
+  numstr = num.floor.to_s.reverse.split(/(...)/)
+              .reject(&:empty?)
+              .map(&:reverse)
+              .reverse
+              .join("_") + dec_str
+  if width.zero?
+    numstr
+  else
+    format "%#{width}s", numstr
+  end
+end

data/milemarker.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/milemarker/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "milemarker"
+  spec.version       = Milemarker::VERSION
+  spec.authors       = ["Bill Dueber"]
+  spec.email         = ["bill@dueber.com"]
+
+  spec.summary       = "Track and produce loglines for batch processing progress."
+  spec.homepage      = "https://github.com/billdueber/milemarker"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage + '/CHANGELOG.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.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  #
+
+  spec.add_development_dependency 'bundler', '~>2.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '~>13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.7'
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: milemarker
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bill Dueber
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        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: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description:
+email:
+- bill@dueber.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/milemarker.rb
+- lib/milemarker/structured.rb
+- lib/milemarker/version.rb
+- lib/ppnum.rb
+- milemarker.gemspec
+homepage: https://github.com/billdueber/milemarker
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/billdueber/milemarker
+  source_code_uri: https://github.com/billdueber/milemarker
+  changelog_uri: https://github.com/billdueber/milemarker/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Track and produce loglines for batch processing progress.
+test_files: []