loginator 0.0.7 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16cb733ff2fbe83f63150fd5abe6027c578a6054
-  data.tar.gz: c8ef72fffaae51fe5cd15476216440b23e1f8afa
+  metadata.gz: 428aba5714b1915bcfea3a857fc67f89a155e8cc
+  data.tar.gz: cfb6fa8598f8a0d38a5aa82e3fd4f6c1d5910b89
 SHA512:
-  metadata.gz: 5d5773959c66a369cffe7dea5117d2b599e73b6131f3dfea049c815e74ac5c64278754efd132b17f75dbab839f06285a24e484cf607ed5998f1a28b9c860e847
-  data.tar.gz: ef38af19158edaec1a56c4bcbafee62303a81e0e2298d0eb288b30748a13cd4f8d74be5327f498c3c56cbc5caff4f1d62ecc457bc75b58d6fea641e36ae7b499
+  metadata.gz: 9762d9e7697e7a2b5a30cd9a5f6927f5a385a05363fe42bcecce74da35836a7b9e9d5638facff39d9c105e5553e6ca574904b7f724b1b4e14fcd1656f3bf1d0f
+  data.tar.gz: eac5555318d79d8e76c5aad08d3c9ca8107d3e2ddfdc4609572165cce517b94795b4a796067e25955fe8aeaaefbc0760061b9ebba59dff6900ee56b0e3c93b91

data/Gemfile

@@ -1,3 +1,9 @@
 source 'https://rubygems.org'
 
 gemspec
+
+# rubocop:disable all
+# This is the jankiest jank in all of janktown. I want a better way to
+# manage dependencies for middleware development.
+eval(File.read('lib/loginator/middleware/Gemfile.middleware'), binding)
+# rubocop:enable all

data/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Greg Poirier
+
+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

@@ -3,8 +3,21 @@
 [![Code Climate](https://codeclimate.com/github/gray-industries/loginator/badges/gpa.svg)](https://codeclimate.com/github/gray-industries/loginator)
 [![Build Status](https://travis-ci.org/gray-industries/loginator.svg)](https://travis-ci.org/gray-industries/loginator)
 
-Loginator is a gem for standardizing the logging of requests and responses for
-remote APIs.
+Loginator is a gem for standardizing different types of log formats. It particularly focuses on standardized
+logging for service interactions in a SOA / distributed application.
+
+I am tired of having useless logs at work, and I wanted to standardize those logs. Jordan Sissel puts it
+much better than me:
+
+> I want to be able to log in a structured way and have the log output know how that should be formatted.
+> Maybe for humans, maybe for computers (as JSON), maybe as some other format. Maybe you want to log to a
+> csv file because that's easy to load into Excel for analysis, but you don't want to change all your
+> applications log methods?
+
+I found this in the README.md for ruby-cabin (jordansissel/ruby-cabin). When I read this, I was pretty
+floored. "Someone else gets it." This is exactly what I'm trying to accomplish with Loginator, but
+I want to take the idea of Cabin in a slightly different direction. It's intended for use in my Gray
+Industries projects, but if someone else finds it useful, that would be amazing.
 
 ## Installation
 
@@ -27,19 +40,46 @@ Or install it yourself as:
 Remote APIs (be they HTTP or otherwise) follow a pattern fairly similar to that
 of a common HTTP API. 
 
-### Requests
-
-A request is typically made to a path with request parameters. We attach
-metadata to this request in order to track it throughout a distributed system.
-This metadata includes a unique identifier and a UTC timestamp.
-
-### Responses
-
-A response is typically yielded to requests. It includes the same metadata
-as a request, but also a response typically has associated with it a status
-code indicating success or failure of some kind (we have chosen to standardize
-around HTTP status codes -- or some interpretation thereof). Like a request,
-a response typically also contains a body.
+### Transactions
+
+Transactions include the following fields:
+  - uuid (string)
+  - timestamp (serialized as a float, otherwise Time)
+  - duration (float)
+  - path (string)
+  - status (integer)
+  - request (string)
+  - response (string)
+  - params (hash)
+
+Custom transactions can be made by extending Transaction. These custom transactions
+could include additional fields, change field types, etc. In general, however, API
+transactions have all or most of these characteristics regardless of protocol.
+
+To use a transaction, wrap your API response generation in a Transaction#begin block
+like so (as seen in the Sinatra middleware):
+
+```
+Loginator::Transaction.new.begin do |txn|
+  txn.path = env['PATH_INFO']
+  txn.request = req
+  status, headers, body = @app.call(env)
+  txn.status = status
+  txn.response = body
+  [status, headers, body]
+end
+```
+
+The begin method will return the last line much like a function, allowing you
+to seemlessly integrate transaction logging into your middleware.
+
+## Middleware
+
+This Gem includes middleware. I am not adding explicit dependencies on the frameworks I'm targeting.
+That being said, I do want to document the version of those frameworks and have put a separate Gemfile
+in `lib/loginator/middleware` that includes the appropriate development dependencies required. I am
+also adding that Gemfile to the gem's root Gemfile to make testing and contributing easier. I think
+it is necessary to draw this distinction, because using Loginator does not explicitly require those gems.
 
 ## Contributing
 

data/lib/loginator/middleware/Gemfile.middleware

@@ -0,0 +1 @@
+gem 'sinatra', '~> 1.4.5'

data/lib/loginator/middleware/sinatra.rb

@@ -0,0 +1,41 @@
+require 'securerandom'
+
+module Loginator
+  module Middleware
+    # Middleware for logging transactions with Sinatra.
+    class Sinatra
+      attr_reader :app, :logger, :transaction
+
+      # @param app [Rack::App] #{Rack::App} being passed through middleware chain
+      # @param logger [IO] #{IO} object where log messages will be sent via puts()
+      def initialize(app, logger)
+        @app = app
+        @logger = logger
+      end
+
+      def call(env)
+        uuid = env['X-REQUEST-ID'] ||= SecureRandom.uuid
+        req = Rack::Request.new(env)
+        @transaction = Loginator::Transaction.new(uuid: uuid)
+        transaction.begin do |txn|
+          txn.path = env['PATH_INFO']
+          txn.request = read_body(req)
+          status, headers, body = @app.call(env)
+          txn.status = status
+          txn.response = body
+          [status, headers, body]
+        end
+      ensure
+        logger.puts(transaction.to_json)
+      end
+
+      protected
+
+      def read_body(req)
+        req.body.read
+      ensure
+        req.body.rewind
+      end
+    end
+  end
+end

data/lib/loginator/transaction.rb

@@ -1,21 +1,137 @@
 require 'securerandom'
 
 module Loginator
-  # Methods for generating transactional metadata.
-  module Transaction
-    def self.from_json(json_str)
-      json = MultiJson.load(json_str)
-      Loginator.const_get(json['type'].capitalize).from_hash(json)
+  # A Loginator::Transaction is meant to encapsulate a single
+  # request/response cycle.
+  class Transaction
+    class << self
+      # @param [String] json JSON body of the given transaction
+      # @return [Transaction]
+      def from_json(json)
+        obj = MultiJson.load(json, symbolize_keys: true)
+        Transaction.new(filter_hash(obj))
+      end
+
+      protected
+
+      # This is the inverse functions for the instance-level
+      # filter_hash.
+      def filter_hash(hsh)
+        [[:timestamp, ->(t) { Time.at(t) }]].map do |k, f|
+          hsh[k] = f.call(hsh[k])
+        end
+        hsh
+      end
+    end
+
+    # The following may look funny to people, but please know that it's simply an attempt to
+    # convey intent. I want Transactions to be thought of as immutable objects. I'd like to
+    # take them in that direction eventually, but doing so in a way that is comprehensible
+    # is difficult. After rewriting the interface to Transaction several times, I settled here.
+    attr_accessor :path, :request, :params, :response, :status
+
+    attr_reader :uuid, :timestamp, :duration
+
+    protected
+
+    attr_writer :uuid, :timestamp, :duration
+
+    public
+
+    # Create a new Loginator::Transaction
+    # @param [Hash] opts The options to create the Loginator::Transaction
+    # @option opts [String]  :uuid UUID (SecureRandom.uuid)
+    # @option opts [Time]    :timestamp (Time.now) Beginning timestamp of transaction
+    # @option opts [Integer] :status Status returned to the requester
+    # @option opts [String]  :path  Path associated with the request
+    # @option opts [String]  :request Body of the request
+    # @option opts [Hash]    :params Parameters of the request
+    # @option opts [String]  :response Body of the response
+    # @option opts [Float]   :duration Duration of the request
+    def initialize(opts = {})
+      # TODO: UUID Generation should have a service interface
+      @uuid = opts.delete(:uuid) || SecureRandom.uuid
+      @timestamp = opts.delete(:timestamp) || Time.now
+      opts.each_pair do |k, v|
+        send("#{k}=", v)
+      end
+    end
+
+    # Marks the beginning of a Transaction. Optionally, will execute
+    # the given block in the context of a transaction, returning the
+    # last line of the block and raising any exceptions thrown in the
+    # block given.
+    #
+    # NOTE: we make a best effort to guarantee that `transaction.finished`
+    # is called via an ensure block, but that is all. We do not set the
+    # status or response. You must do so in your block if you wish to
+    # record any failures.
+    # @param [Block] &blk optional
+    # @yield [Transaction] the transaction object after it has been updated
+    # @return [] Returns whatever the block returns
+    def begin
+      @timestamp = Time.now
+      # NOTE: yield self is a bit of a smell to me, but I am okay with this
+      # as the block is evaluated in the context of the caller and not of
+      # the Transaction object.
+      yield self if block_given?
+    ensure
+      finished
+    end
+
+    # Marks the end of the transaction.
+    #
+    # NOTE: Once set, duration should be considered immutable. I.e. you
+    # cannot affect the duration of this Transaction by calling finished
+    # twice.
+    # @return [Time] time of the end of the transaction
+    def finished
+      fin = Time.now
+      @duration ||= calculate_duration(fin)
+      fin
+    end
+
+    # Hashify the Transaction
+    # @return [Hash]
+    def to_h
+      [:uuid, :timestamp, :status, :path, :request, :params, :response, :duration].each_with_object({}) do |key, hsh|
+        hsh[key] = send(key)
+      end
     end
 
-    # Generate a UUID for this transaction.
-    def uuid
-      SecureRandom.uuid
+    # JSONify the Transaction
+    # @return [String]
+    def to_json
+      MultiJson.dump(filter_hash!(to_h))
+    end
+
+    # Two Transactions are considered equivalent if the following
+    # are all equal:
+    # UUID, Duration, Response, Path, Request, Parameters.
+    # This is largely used for testing serialization/deserialization.
+    def ==(other)
+      timestamp.to_f == other.timestamp.to_f &&
+        [:uuid, :duration, :response, :path, :request, :params].all? { |k| send(k) == other.send(k) }
+    end
+
+    protected
+
+    # @param [Time] t ending timestamp of the transaction
+    # @return [Float] duration of the transaction
+    def calculate_duration(t)
+      (t - timestamp).to_f
     end
 
-    # Format the time as a float.
-    def format_time
-      Time.now.utc.to_f
+    # Filter the transaction hash's elements based on a mapping of
+    # element->proc pairs. This is largely for serialization/deserialization.
+    # NOTE: This modifies the hash in place.
+    # @param [Hash] hsh the hash to be modified
+    # @return [Hash] the modified hash
+    def filter_hash!(hsh)
+      [[:timestamp, ->(t) { t.to_f }]].each do |k, f|
+        hsh[k] = f.call(hsh[k])
+      end
+      hsh
     end
   end
 end

data/lib/loginator/version.rb

@@ -1,4 +1,4 @@
 # Increment when releasing.
 module Loginator
-  VERSION = '0.0.7'
+  VERSION = '0.1.1'
 end

data/lib/loginator.rb

@@ -1,6 +1,4 @@
 require 'loginator/version'
-require 'loginator/request'
-require 'loginator/response'
 require 'loginator/transaction'
 
 # Loginator

data/loginator.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |gem|
   gem.description   = 'Standardized logging of API requests/responses'
   gem.summary       = 'Loginator is a mechanism for standardizing the logging of API requests and responses.'
 
+  gem.licenses      = ['MIT']
   gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
   gem.executables   = gem.files.grep(/^bin\//).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(/^(test|spec|features)\//)
@@ -17,10 +18,6 @@ Gem::Specification.new do |gem|
   gem.version       = Loginator::VERSION
 
   # dependencies...
-  gem.add_dependency('thor', '0.19.1')
-  gem.add_dependency('sysexits', '1.0.2')
-  gem.add_dependency('awesome_print', '~> 1.1.0')
-  gem.add_dependency('abstract_type', '~> 0.0.7')
   gem.add_dependency('multi_json', '~> 1.10.1')
 
   # development dependencies.

data/spec/integration/lib/loginator/middleware/sinatra_spec.rb

@@ -0,0 +1,60 @@
+require 'loginator/middleware/sinatra'
+require 'rack'
+
+describe Loginator::Middleware::Sinatra do
+  let(:app) { ->(_env) { response } }
+  let(:response) { [200, env, 'app'] }
+  let(:env) { Rack::MockRequest.env_for('http://test/path', input: body) }
+  let(:body) { StringIO.new('Request body') }
+  let(:logger) { StringIO.new }
+  let(:transaction) { subject.transaction }
+
+  subject { described_class.new(app, logger) }
+
+  context 'app call succeeds' do
+    before do
+      subject.call(env)
+    end
+
+    it 'adds the UUID to the sinatra env' do
+      expect(transaction.uuid).to be_a_kind_of(String)
+    end
+
+    it 'rewinds the Sinatra request body' do
+      expect(body.eof?).to be_falsey
+    end
+
+    it 'sets the request path' do
+      expect(transaction.path).to eq('/path')
+    end
+
+    it 'sets the request body' do
+      expect(transaction.request).to eq(body.string)
+    end
+
+    it 'sets the timestamp' do
+      expect(transaction.timestamp).to be_a_kind_of(Time)
+    end
+
+    it 'sets the response code' do
+      expect(transaction.status).to eq(200)
+    end
+
+    it 'sets the response body' do
+      expect(transaction.response).to eq('app')
+    end
+
+    it 'logs the transaction' do
+      expect(logger.string.chomp).to eq(transaction.to_json)
+    end
+  end
+
+  context 'app call fails' do
+    let(:app) { ->(_env) { fail } }
+    before { expect { subject.call(env) }.to raise_error }
+
+    it 'still logs the message' do
+      expect(logger.string.chomp).to eq(transaction.to_json)
+    end
+  end
+end

data/spec/integration/lib/loginator/transaction_spec.rb

@@ -1,23 +1,139 @@
 require 'loginator/transaction'
 
 RSpec.describe Loginator::Transaction do
-  subject { Loginator.const_get(type).new }
+  describe '#new' do
+    before do
+      subject.finished
+    end
 
-  describe '.from_json' do
-    context 'when passed a request json body' do
-      let(:type) { 'Request' }
+    context 'using defaults' do
+      it 'creates a valid object' do
+        expect(subject).to be_a_kind_of(described_class)
+      end
+
+      it 'sets default request id' do
+        expect(subject.uuid).to be_a_kind_of(String)
+      end
+
+      it 'sets default timestamp' do
+        expect(subject.timestamp).to be_a_kind_of(Time)
+        expect(subject.timestamp).to be <= Time.now
+      end
+    end
+
+    context 'overriding defaults' do
+      let(:uuid) { 'uuid' }
+      let(:timestamp) { Time.at(42) }
+      let(:path) { '/' }
+
+      subject { described_class.new(uuid: uuid, timestamp: timestamp, duration: 0, path: path) }
+
+      [:uuid, :timestamp, :path].each do |field|
+        it 'overrides defaults' do
+          expect(subject.send(field)).to eq(send(field))
+        end
+      end
 
-      it 'returns a request' do
-        expect(Loginator::Transaction.from_json(subject.to_json)).to be_a_kind_of(Loginator::Request)
+      describe '.from_json' do
+        it 'faithfully deserializes' do
+          expect(described_class.from_json(subject.to_json)).to eq(subject)
+        end
       end
     end
+  end
+
+  describe '#finished' do
+    before do
+      subject.finished
+    end
+
+    it 'sets a positive float for the duration' do
+      expect(subject.duration).to be_a_kind_of(Float)
+      expect(subject.duration).to be > 0.0
+    end
+  end
 
-    context 'when passed a response json body' do
-      let(:type) { 'Response' }
+  describe '#begin' do
+    shared_examples_for 'transaction#begin' do
+      it 'marks the beginning of the transaction' do
+        expect(subject.timestamp).to be_a_kind_of(Time)
+      end
+
+      it 'executes the block' do
+        expect(@in_block.to_f).to be > subject.timestamp.to_f
+      end
 
-      it 'recognizes a response' do
-        expect(Loginator::Transaction.from_json(subject.to_json)).to be_a_kind_of(Loginator::Response)
+      it 'marks the end of the transaction after the block is finished' do
+        expect((subject.timestamp + subject.duration).to_f).to be > @in_block.to_f
       end
     end
+
+    context 'when the block executes normally' do
+      before do
+        subject.begin do
+          sleep 0.01
+          @in_block = Time.now
+        end
+
+        it_behaves_like 'transaction#begin'
+      end
+    end
+
+    context 'when the block passed raises an exception' do
+      before do
+        expect do
+          subject.begin do
+            sleep 0.01
+            @in_block = Time.now
+            fail
+          end
+        end.to raise_error
+      end
+
+      it_behaves_like 'transaction#begin'
+    end
+  end
+
+  describe '#to_json' do
+    let(:json) { MultiJson.dump(hash) }
+
+    let(:hash) do
+      {
+        'uuid' => '1',
+        'timestamp' => 0.0,
+        'duration' => 1.0,
+        'path' => '/',
+        'status' => 0,
+        'request' => '',
+        'response' => '',
+        'params' => {}
+      }
+    end
+
+    subject { described_class.from_json(json) }
+
+    before do
+      subject.finished
+    end
+
+    it 'faithfully serializes' do
+      %w(uuid duration path status request response params).each do |k|
+        expect(subject.send(k)).to eq(hash[k])
+      end
+
+      expect(subject.timestamp.to_f).to eq(hash['timestamp'])
+    end
+  end
+
+  describe '.from_json' do
+    subject { described_class.new(duration: 1.0, timestamp: Time.now) }
+
+    before do
+      subject.finished
+    end
+
+    it 'faithfully deserializes' do
+      expect(described_class.from_json(subject.to_json)).to eq(subject)
+    end
   end
 end

metadata

@@ -1,71 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: loginator
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.1
 platform: ruby
 authors:
 - Greg Poirier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-14 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.19.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.19.1
-- !ruby/object:Gem::Dependency
-  name: sysexits
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.0.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.0.2
-- !ruby/object:Gem::Dependency
-  name: awesome_print
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-- !ruby/object:Gem::Dependency
-  name: abstract_type
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.7
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -262,14 +206,14 @@ files:
 - ".travis.yml"
 - Gemfile
 - Guardfile
+- LICENSE.md
 - README.md
 - Rakefile
 - examples/rack/logging.rb
 - examples/rack/uuid.rb
 - lib/loginator.rb
-- lib/loginator/jsonable_struct.rb
-- lib/loginator/request.rb
-- lib/loginator/response.rb
+- lib/loginator/middleware/Gemfile.middleware
+- lib/loginator/middleware/sinatra.rb
 - lib/loginator/transaction.rb
 - lib/loginator/version.rb
 - loginator.gemspec
@@ -277,17 +221,15 @@ files:
 - spec/fixtures.rb
 - spec/fixtures/.gitignore
 - spec/integration/lib/loginator/.gitignore
-- spec/integration/lib/loginator/request_spec.rb
-- spec/integration/lib/loginator/response_spec.rb
+- spec/integration/lib/loginator/middleware/sinatra_spec.rb
 - spec/integration/lib/loginator/transaction_spec.rb
 - spec/resources.rb
 - spec/resources/.gitignore
 - spec/spec_helper.rb
-- spec/support/shared/lib/loginator/jsonable_struct_spec.rb
-- spec/support/shared/lib/loginator/struct_with_defaults_spec.rb
 - spec/unit/lib/loginator/.gitignore
 homepage: 
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -315,13 +257,10 @@ test_files:
 - spec/fixtures.rb
 - spec/fixtures/.gitignore
 - spec/integration/lib/loginator/.gitignore
-- spec/integration/lib/loginator/request_spec.rb
-- spec/integration/lib/loginator/response_spec.rb
+- spec/integration/lib/loginator/middleware/sinatra_spec.rb
 - spec/integration/lib/loginator/transaction_spec.rb
 - spec/resources.rb
 - spec/resources/.gitignore
 - spec/spec_helper.rb
-- spec/support/shared/lib/loginator/jsonable_struct_spec.rb
-- spec/support/shared/lib/loginator/struct_with_defaults_spec.rb
 - spec/unit/lib/loginator/.gitignore
 has_rdoc: 

data/lib/loginator/jsonable_struct.rb

@@ -1,45 +0,0 @@
-require 'multi_json'
-
-module Loginator
-  # Makes a Struct easily serializable and deserializable. Adds the
-  # from_json class method and to_json instance method to Struct
-  # classes.
-  module JsonableStruct
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    # class level mixins
-    module ClassMethods #:nodoc
-      def from_hash(hsh)
-        hsh_type = hsh.delete('type')
-        fail(ArgumentError, format('Incorrect message type: %s', hsh_type)) unless hsh_type == type
-        fail(ArgumentError, format('Hash must contain keys: %s', members.join(', '))) unless valid_hash?(hsh)
-        new(*hsh.values)
-      end
-
-      def from_json(json_str)
-        json = MultiJson.load(json_str)
-        from_hash(json)
-      end
-
-      def type
-        @type ||= name.split('::').last.downcase.freeze
-      end
-
-      private
-
-      def valid_hash?(hsh)
-        # Loosely validate that all necessary keys are present...
-        # This does mean that we could potentially create a Response from a hash
-        # representing an object _like_ a response.... Feature or... ? ^_^
-        members & hsh.keys.map(&:to_sym) == members
-      end
-    end #:rubocop:enable documentation
-
-    def to_json
-      MultiJson.dump(to_h.merge(type: self.class.type))
-    end
-    alias_method :to_s, :to_json
-  end
-end

data/lib/loginator/request.rb

@@ -1,25 +0,0 @@
-require 'multi_json'
-require 'loginator/jsonable_struct'
-require 'loginator/transaction'
-
-# Loginator::Request
-module Loginator
-  # A request is a tuple of a (UUID, Timestamp, Path, Parameters). Requests parameters are defined subjectively by the
-  # user. For example, in the example Rack middleware ({#Rack::Loginator::Logging}), we define params as the request
-  # body (our HTTP APIs tend to accept JSON bodies as opposed to parameters attached to the URL). You may also wish
-  # to consider part of the HTTP headers as a request parameter.
-  #
-  Request = Struct.new(:request_id, :timestamp, :path, :params) do
-    include Loginator::JsonableStruct
-    include Loginator::Transaction
-
-    # Create a new Loginator::Request
-    # @param request_id [String] (SecureRandom.uuid) Unique identifier for the request
-    # @param timestamp [Float]   (Time.now.utc.to_f) Time of the request
-    # @param path [String]       (nil)               Path associated with the request
-    # @param params [String]     ({})                Parameters of the request
-    def initialize(request_id = uuid, timestamp = format_time, path = nil, params = {})
-      super
-    end
-  end
-end

data/lib/loginator/response.rb

@@ -1,27 +0,0 @@
-require 'multi_json'
-require 'loginator/jsonable_struct'
-require 'loginator/transaction'
-
-# Loginator::Response
-module Loginator
-  # A {#Loginator::Response} is a response to a {#Loginator::Request}. It should include the same elements as a
-  # request, plus the status of the response (an indicator if the API request was successful or not) as well
-  # as an optional response body. Whether or not to log the response is entirely left up to implementation
-  # decisions and production log volume considerations. It is trivial to log response bodies in development,
-  # but not in production.
-  #
-  Response = Struct.new(:request_id, :timestamp, :path, :status, :body) do
-    include Loginator::JsonableStruct
-    include Loginator::Transaction
-
-    # Create a new Loginator::Response
-    # @param request_id [String] (SecureRandom.uuid) Unique identifier for the request
-    # @param timestamp [Float]   (Time.now.utc.to_f) Time of the request
-    # @param path [String]       (nil)               Path associated with the request
-    # @param status [Integer]    (0)                 Status returned to the requester
-    # @param body [String]       ({})                Parameters of the request
-    def initialize(request_id = uuid, timestamp = format_time, path = nil, status = 0, body = '')
-      super
-    end
-  end
-end

data/spec/integration/lib/loginator/request_spec.rb

@@ -1,13 +0,0 @@
-require 'loginator/request'
-require 'support/shared/lib/loginator/jsonable_struct_spec'
-require 'support/shared/lib/loginator/struct_with_defaults_spec'
-
-RSpec.describe Loginator::Request do
-  describe '#new' do
-    it_behaves_like 'struct_with_defaults'
-  end
-
-  describe 'serializability' do
-    it_behaves_like 'jsonable_struct'
-  end
-end

data/spec/integration/lib/loginator/response_spec.rb

@@ -1,13 +0,0 @@
-require 'loginator/response'
-require 'support/shared/lib/loginator/jsonable_struct_spec'
-require 'support/shared/lib/loginator/struct_with_defaults_spec'
-
-RSpec.describe Loginator::Response do
-  describe '#new' do
-    it_behaves_like 'struct_with_defaults'
-  end
-
-  describe 'serializability' do
-    it_behaves_like 'jsonable_struct'
-  end
-end

data/spec/support/shared/lib/loginator/jsonable_struct_spec.rb

@@ -1,13 +0,0 @@
-shared_examples_for 'jsonable_struct' do
-  describe '#to_json' do
-    it 'faithfully serializes' do
-      expect(subject.to_json).to eq(subject.to_h.merge(type: described_class.type).to_json)
-    end
-  end
-
-  describe '.from_json' do
-    it 'faithfully deserializes' do
-      expect(described_class.from_json(subject.to_json)).to eq(subject)
-    end
-  end
-end

data/spec/support/shared/lib/loginator/struct_with_defaults_spec.rb

@@ -1,39 +0,0 @@
-shared_examples_for 'struct_with_defaults' do
-  describe '#new' do
-    context 'using defaults' do
-      it 'creates a valid object' do
-        expect(subject).to be_a_kind_of(described_class)
-      end
-
-      it 'sets default request id' do
-        expect(subject.request_id).to be_a_kind_of(String)
-      end
-
-      it 'sets default timestamp' do
-        expect(subject.timestamp).to be_a_kind_of(Float)
-        expect(subject.timestamp).to be <= Time.now.utc.to_f
-        expect(subject.timestamp).to be > 0.0
-      end
-    end
-
-    context 'overriding defaults' do
-      let(:request_id) { 'uuid' }
-      let(:timestamp) { 42 }
-      let(:path) { '/' }
-
-      subject { described_class.new(request_id, timestamp, path) }
-
-      [:request_id, :timestamp, :path].each do |field|
-        it 'overrides defaults' do
-          expect(subject.send(field)).to eq(send(field))
-        end
-      end
-
-      describe '.from_json' do
-        it 'faithfully deserializes' do
-          expect(described_class.from_json(subject.to_json)).to eq(subject)
-        end
-      end
-    end
-  end
-end