journaled 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 067a7a010e80a13c5a9204e8e761e949af52243e
+  data.tar.gz: e5e072be8c838c63dfbbc082b51d709ed11eef6a
+SHA512:
+  metadata.gz: 93726fa7a7c41e57cb7c7a73c6d5bee57d83562e7d52e51306cb1fc0bc25760ca959c5ba256c5415be8df0c45084486eea809372d701d33b5386e3d0dbba5b2c
+  data.tar.gz: 9c8aea433e5c9ffbdd5039036ea860a9c8cd464ed29fa9330bbbb936ac725b97e3b1c98eb20ea4e612ea33bddf926b80bceb02c412e55f2d0dca78ac3472d666

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017-2019 Betterment
+
+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,194 @@
+# Journaled
+
+A Rails engine to durably deliver schematized events to Amazon Kinesis via DelayedJob.
+
+More specifically, `journaled` is composed of three opinionated pieces:
+schema definition/validation via JSON Schema, transactional enqueueing
+via Delayed::Job (specifically `delayed_job_active_record`), and event
+transmission via Amazon Kinesis. Our current use-cases include
+transmitting audit events for durable storage in S3 and/or analytical
+querying in Amazon Redshift.
+
+Journaled provides an at-least-once event delivery guarantee assuming
+Delayed::Job is configured not to delete jobs on failure.
+
+Note: Do not use the journaled gem to build an event sourcing solution
+as it does not guarantee total ordering of events. It's possible we'll
+add scoped ordering capability at a future date (and would gladly
+entertain pull requests), but it is presently only designed to provide a
+durable, eventually consistent record that discrete events happened.
+
+## Installation
+
+1. [Install `delayed_job_active_record`](https://github.com/collectiveidea/delayed_job_active_record#installation)
+if you haven't already.
+
+
+2. To integrate Journaled into your application, simply include the gem in your 
+app's Gemfile.
+    ```
+    gem 'journaled', https_github: 'Betterment/journaled'
+    ```
+3. You will also need to define the following environment variables to allow Journaled to publish events to your AWS Kinesis event stream:
+
+  * `JOURNALED_STREAM_NAME`
+
+Special case: if your `Journaled::Event` objects override the
+`#journaled_app_name` method to a non-nil value e.g. `my_app`, you will
+instead need to provide a corresponding
+`[upcased_app_name]_JOURNALED_STREAM_NAME` variable for each distinct
+value, e.g. `MY_APP_JOURNALED_STREAM_NAME`. You can provide a default value
+for all `Journaled::Event`s in an initializer like this:
+
+```ruby
+Journaled.default_app_name = 'my_app'
+```
+
+You may optionally define the following ENV vars to specify AWS
+credentials outside of the locations that the AWS SDK normally looks:
+
+  * `RUBY_AWS_ACCESS_KEY_ID`
+  * `RUBY_AWS_SECRET_ACCESS_KEY`
+
+You may also specify the region to target your AWS stream by setting
+`AWS_DEFAULT_REGION`. If you don't specify, Journaled will default to
+`us-east-1`.
+
+Journaled::Event provides a `commit_hash` method which you may journal
+if you like. If you choose to use it, you must provide a `GIT_COMMIT`
+environment variable.
+
+## Usage
+
+### Change Journaling
+
+Out of the box, `Journaled` provides an event type and ActiveRecord
+mix-in for durably journaling changes to your model, implemented via
+ActiveRecord hooks. Use it like so:
+
+```
+class User < ApplicationRecord
+  include Journaled::Changes
+
+  journal_changes_to :email, :first_name, :last_name, as: :identity_change
+end
+```
+
+Add the following to your controller base class for attribution:
+
+```
+class ApplicationController < ActionController::Base
+  include Journaled::Actor
+
+  self.journaled_actor = :current_user # Or your authenticated entity
+end
+```
+
+Your authenticated entity must respond to `#to_global_id`, which
+ActiveRecords do by default.
+
+Every time any of the specified attributes is modified, or a `User`
+record is created or destroyed, an event will be sent to Kinesis with the following attributes:
+
+  * `id` - a random event-specific UUID
+  * `event_type` - the constant value `journaled_change`
+  * `created_at`- when the event was created
+  * `table_name` - the table name backing the ActiveRecord (e.g. `users`)
+  * `record_id` - the primary key of the record, as a string (e.g.
+    `"300"`)
+  * `database_operation` - one of `create`, `update`, `delete`
+  * `logical_operation` - whatever logical operation you specified in
+    your `journal_changes_to` declaration (e.g. `identity_change`)
+  * `changes` - a serialized JSON object representing the latest values
+    of any new or changed attributes from the specified set (e.g.
+    `{"email":"mynewemail@example.com"}`)
+  * `actor` - a string (usually a rails global_id) representing who
+    performed the action.
+
+### Custom Journaling
+
+For every custom implementation of journaling in your application, define the JSON schema for the attributes in your event. 
+This schema file should live in your Rails application at the top level and should be named in snake case to match the 
+class being journaled.
+    E.g.: `your_app/journaled_schemas/my_class.json)`
+    
+In each class you intend to use Journaled, include the `Journaled::Event` module and define the attributes you want 
+captured. After completing the above steps, you can call the `journal!` method in the model code and the declared 
+attributes will be published to the Kinesis stream. Be sure to call
+`journal!` within the same transaction as any database side effects of
+your business logic operation to ensure that the event will eventually
+be delivered if-and-only-if your transaction commits.
+
+Example:
+
+```js
+// journaled_schemas/contract_acceptance_event.json
+
+{
+  "type": "object",
+  "title": "contract_acceptance_event",
+  "required": [
+    "user_id",
+    "signature"
+  ],
+  "properties": {
+    "user_id": {
+      "type": "integer"
+    },
+    "signature": {
+      "type": "string"
+    }
+  }
+}
+```
+
+```ruby
+# app/models/contract_acceptance_event.rb
+
+ContractAcceptanceEvent = Struct.new(:user_id, :signature) do
+  include Journaled::Event
+
+  journal_attributes :user_id, :signature
+end
+```
+
+```ruby
+# app/models/contract_acceptance.rb
+
+class ContractAcceptance
+  include ActiveModel::Model
+  
+  attr_accessor :user_id, :signature
+
+  def user
+    @user ||= User.find(user_id)
+  end
+
+  def contract_acceptance_event
+    @contract_acceptance_event ||= ContractAcceptanceEvent.new(user_id, signature)
+  end
+
+  def save!
+    User.transaction do
+      user.update!(contract_accepted: true)
+      contract_acceptance_event.journal!
+    end
+  end
+end
+```
+
+An event like the following will be journaled to kinesis:
+
+```js
+{
+  "id": "bc7cb6a6-88cf-4849-a4f0-a31b0b199c47", // A random event ID for idempotency filtering
+  "event_type": "contract_acceptance_event",
+  "created_at": "2019-01-28T11:06:54.928-05:00",
+  "user_id": 123,
+  "signature": "Sarah T. User"
+}
+```
+
+## Future improvements & issue tracking
+Suggestions for enhancements to this engine are currently being tracked via Github Issues. Please feel free to open an
+issue for a desired feature, as well as for any observed bugs.

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Journaled'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+if %w(development test).include? Rails.env
+  require 'rspec/core'
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new
+
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+
+  task(:default).clear
+  task default: %i(rubocop spec)
+end

data/app/controllers/concerns/journaled/actor.rb

@@ -0,0 +1,18 @@
+module Journaled::Actor
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :_journaled_actor_method_name, instance_accessor: false, instance_predicate: false
+    before_action do
+      RequestStore.store[:journaled_actor_proc] = self.class._journaled_actor_method_name &&
+        -> { send(self.class._journaled_actor_method_name) }
+    end
+  end
+
+  class_methods do
+    def journaled_actor=(method_name)
+      raise "Must provide a symbol method name" unless method_name.is_a?(Symbol)
+      self._journaled_actor_method_name = method_name
+    end
+  end
+end

data/app/models/concerns/journaled/changes.rb

@@ -0,0 +1,38 @@
+module Journaled::Changes
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :_journaled_change_definitions
+    self._journaled_change_definitions = []
+
+    after_create do
+      self.class._journaled_change_definitions.each do |definition|
+        Journaled::ChangeWriter.new(model: self, change_definition: definition).create
+      end
+    end
+
+    after_save unless: :saved_change_to_id? do
+      self.class._journaled_change_definitions.each do |definition|
+        Journaled::ChangeWriter.new(model: self, change_definition: definition).update
+      end
+    end
+
+    after_destroy do
+      self.class._journaled_change_definitions.each do |definition|
+        Journaled::ChangeWriter.new(model: self, change_definition: definition).delete
+      end
+    end
+  end
+
+  class_methods do
+    def journal_changes_to(*attribute_names, as:) # rubocop:disable Naming/UncommunicativeMethodParamName
+      if attribute_names.empty? || attribute_names.any? { |n| !n.is_a?(Symbol) }
+        raise "one or more symbol attribute_name arguments is required"
+      end
+
+      raise "as: must be a symbol" unless as.is_a?(Symbol)
+
+      _journaled_change_definitions << Journaled::ChangeDefinition.new(attribute_names: attribute_names, logical_operation: as)
+    end
+  end
+end

data/app/models/journaled/change.rb

@@ -0,0 +1,34 @@
+class Journaled::Change
+  include Journaled::Event
+
+  attr_reader :table_name,
+    :record_id,
+    :database_operation,
+    :logical_operation,
+    :changes,
+    :journaled_app_name,
+    :actor
+
+  journal_attributes :table_name,
+    :record_id,
+    :database_operation,
+    :logical_operation,
+    :changes,
+    :actor
+
+  def initialize(table_name:, # rubocop:disable Metrics/ParameterLists
+                 record_id:,
+                 database_operation:,
+                 logical_operation:,
+                 changes:,
+                 journaled_app_name:,
+                 actor:)
+    @table_name = table_name
+    @record_id = record_id
+    @database_operation = database_operation
+    @logical_operation = logical_operation
+    @changes = changes
+    @journaled_app_name = journaled_app_name
+    @actor = actor
+  end
+end

data/app/models/journaled/change_definition.rb

@@ -0,0 +1,8 @@
+class Journaled::ChangeDefinition
+  attr_reader :attribute_names, :logical_operation
+
+  def initialize(attribute_names:, logical_operation:)
+    @attribute_names = attribute_names
+    @logical_operation = logical_operation
+  end
+end

data/app/models/journaled/change_writer.rb

@@ -0,0 +1,81 @@
+class Journaled::ChangeWriter
+  attr_reader :model, :change_definition
+  delegate :logical_operation, to: :change_definition
+
+  def initialize(model:, change_definition:)
+    @model = model
+    @change_definition = change_definition
+  end
+
+  def attribute_names
+    @attribute_names ||= change_definition.attribute_names.map(&:to_s)
+  end
+
+  def create
+    journaled_change_for("create", relevant_attributes).journal!
+  end
+
+  def update
+    journaled_change_for("update", relevant_changes).journal! if relevant_changes.present?
+  end
+
+  def delete
+    journaled_change_for("delete", {}).journal!
+  end
+
+  def journaled_change_for(database_operation, changes)
+    Journaled::Change.new(
+      table_name: model.class.table_name,
+      record_id: model.id.to_s,
+      database_operation: database_operation,
+      logical_operation: logical_operation,
+      changes: JSON.dump(changes),
+      journaled_app_name: journaled_app_name,
+      actor: actor_uri
+    )
+  end
+
+  def relevant_attributes
+    model.attributes.slice(*attribute_names)
+  end
+
+  def relevant_changes
+    relevant_changes_with_previous_values.each_with_object({}) do |(k, v), result|
+      result[k] = v[1]
+    end
+  end
+
+  def actor_uri
+    actor_global_id_uri || fallback_global_id_uri
+  end
+
+  private
+
+  def actor_global_id_uri
+    actor.to_global_id.to_s if actor
+  end
+
+  def actor
+    @actor ||= RequestStore.store[:journaled_actor_proc]&.call
+  end
+
+  def fallback_global_id_uri
+    if defined?(::Rails::Console) || File.basename($PROGRAM_NAME) == "rake"
+      "gid://local/#{Etc.getlogin}"
+    else
+      "gid://#{Rails.application.config.global_id.app}"
+    end
+  end
+
+  def relevant_changes_with_previous_values
+    model.saved_changes.slice(*attribute_names)
+  end
+
+  def journaled_app_name
+    if model.class.respond_to?(:journaled_app_name)
+      model.class.journaled_app_name
+    else
+      Journaled.default_app_name
+    end
+  end
+end

data/app/models/journaled/delivery.rb

@@ -0,0 +1,61 @@
+class Journaled::Delivery
+  DEFAULT_REGION = 'us-east-1'.freeze
+
+  def initialize(serialized_event:, partition_key:, app_name:)
+    @serialized_event = serialized_event
+    @partition_key = partition_key
+    @app_name = app_name
+  end
+
+  def perform
+    kinesis_client.put_record record if Journaled.enabled?
+  rescue Aws::Kinesis::Errors::InternalFailure, Aws::Kinesis::Errors::ServiceUnavailable, Aws::Kinesis::Errors::Http503Error => e
+    Rails.logger.error "Kinesis Error - Server Error occurred - #{e.class}"
+    raise KinesisTemporaryFailure
+  rescue Seahorse::Client::NetworkingError => e
+    Rails.logger.error "Kinesis Error - Networking Error occurred - #{e.class}"
+    raise KinesisTemporaryFailure
+  end
+
+  def stream_name
+    env_var_name = [app_name&.upcase, 'JOURNALED_STREAM_NAME'].compact.join('_')
+    ENV.fetch(env_var_name)
+  end
+
+  def kinesis_client_config
+    {
+      region: ENV.fetch('AWS_DEFAULT_REGION', DEFAULT_REGION),
+      retry_limit: 0
+    }.merge(legacy_credentials_hash)
+  end
+
+  private
+
+  attr_reader :serialized_event, :partition_key, :app_name
+
+  def record
+    {
+      stream_name: stream_name,
+      data: serialized_event,
+      partition_key: partition_key
+    }
+  end
+
+  def kinesis_client
+    @kinesis_client ||= Aws::Kinesis::Client.new(kinesis_client_config)
+  end
+
+  def legacy_credentials_hash
+    if ENV.key?('RUBY_AWS_ACCESS_KEY_ID')
+      {
+        access_key_id: ENV.fetch('RUBY_AWS_ACCESS_KEY_ID'),
+        secret_access_key: ENV.fetch('RUBY_AWS_SECRET_ACCESS_KEY')
+      }
+    else
+      {}
+    end
+  end
+
+  class KinesisTemporaryFailure < NotTrulyExceptionalError
+  end
+end

data/app/models/journaled/event.rb

@@ -0,0 +1,65 @@
+module Journaled::Event
+  extend ActiveSupport::Concern
+
+  def journal!
+    Journaled::Writer.new(journaled_event: self).journal!
+  end
+
+  # Base attributes
+
+  def id
+    @id ||= SecureRandom.uuid
+  end
+
+  def event_type
+    @event_type ||= self.class.event_type
+  end
+
+  def created_at
+    @created_at ||= Time.zone.now
+  end
+
+  def commit_hash
+    @commit_hash ||= ENV.fetch('GIT_COMMIT')
+  end
+
+  # Event metadata and configuration (not serialized)
+
+  def journaled_schema_name
+    self.class.to_s.underscore
+  end
+
+  def journaled_attributes
+    self.class.public_send(:journaled_attributes).each_with_object({}) do |attribute, memo|
+      memo[attribute] = public_send(attribute)
+    end
+  end
+
+  def journaled_partition_key
+    event_type
+  end
+
+  def journaled_app_name
+    Journaled.default_app_name
+  end
+
+  private
+
+  class_methods do
+    def journal_attributes(*args)
+      journaled_attributes.concat(args)
+    end
+
+    def journaled_attributes
+      @journaled_attributes ||= []
+    end
+
+    def event_type
+      name.underscore.parameterize(separator: '_')
+    end
+  end
+
+  included do
+    journal_attributes :id, :event_type, :created_at
+  end
+end

data/app/models/journaled/job_priority.rb

@@ -0,0 +1,5 @@
+module Journaled::JobPriority
+  INTERACTIVE = 0 # These jobs will actively hinder end-user interactions until complete, e.g. assembling a report a user is polling for.
+  USER_VISIBLE = 10 # These jobs have end-user-visible side effects that will not obviously impact customers, e.g. welcome emails
+  EVENTUAL = 20 # These jobs affect business process that are tolerant to some degree of queue backlog, e.g. desk record synchronization
+end

data/app/models/journaled/json_schema_model/validator.rb

@@ -0,0 +1,38 @@
+class Journaled::JsonSchemaModel::Validator
+  def initialize(schema_name)
+    @schema_name = schema_name
+  end
+
+  def validate!(json_to_validate)
+    JSON::Validator.validate!(json_schema, json_to_validate)
+  end
+
+  private
+
+  attr_reader :schema_name
+
+  def json_schema
+    @json_schema ||= JSON.parse(json_schema_file)
+  end
+
+  def json_schema_file
+    @json_schema_file ||= File.read(json_schema_path)
+  end
+
+  def json_schema_path
+    @json_schema_path ||= gem_paths.detect { |path| File.exist?(path) } || raise(<<~ERROR)
+      journaled_schemas/#{schema_name}.json not found in any of #{Journaled.schema_providers.map { |sp| "#{sp}.root" }.join(', ')}
+
+      You can add schema providers as follows:
+
+      # config/initializers/journaled.rb
+      Journaled.schema_providers << MyGem::Engine
+    ERROR
+  end
+
+  def gem_paths
+    Journaled.schema_providers.map do |engine|
+      engine.root.join "journaled_schemas/#{schema_name}.json"
+    end
+  end
+end

data/app/models/journaled/not_truly_exceptional_error.rb

@@ -0,0 +1,2 @@
+class Journaled::NotTrulyExceptionalError < RuntimeError
+end

data/app/models/journaled/writer.rb

@@ -0,0 +1,63 @@
+class Journaled::Writer
+  EVENT_METHOD_NAMES = %i(
+    journaled_schema_name
+    journaled_partition_key
+    journaled_attributes
+    journaled_app_name
+  ).freeze
+
+  def initialize(journaled_event:, priority: Journaled::JobPriority::EVENTUAL)
+    raise "An enqueued event must respond to: #{EVENT_METHOD_NAMES.to_sentence}" unless respond_to_all?(journaled_event, EVENT_METHOD_NAMES)
+
+    unless journaled_event.journaled_schema_name.present? &&
+        journaled_event.journaled_partition_key.present? &&
+        journaled_event.journaled_attributes.present?
+      raise <<~ERROR
+        An enqueued event must have a non-nil response to:
+          #json_schema_name,
+          #partition_key, and
+          #journaled_attributes
+      ERROR
+    end
+
+    @journaled_event = journaled_event
+    @priority = priority
+  end
+
+  def journal!
+    base_event_json_schema_validator.validate! serialized_event
+    json_schema_validator.validate! serialized_event
+    Delayed::Job.enqueue journaled_delivery, priority: priority
+  end
+
+  private
+
+  attr_reader :journaled_event, :priority
+  delegate :journaled_schema_name, :journaled_attributes, :journaled_partition_key, :journaled_app_name, to: :journaled_event
+
+  def journaled_delivery
+    @journaled_delivery ||= Journaled::Delivery.new(
+      serialized_event: serialized_event,
+      partition_key: journaled_partition_key,
+      app_name: journaled_app_name
+    )
+  end
+
+  def serialized_event
+    @serialized_event ||= journaled_attributes.to_json
+  end
+
+  def json_schema_validator
+    @json_schema_validator ||= Journaled::JsonSchemaModel::Validator.new(journaled_schema_name)
+  end
+
+  def base_event_json_schema_validator
+    @base_event_json_schema_validator ||= Journaled::JsonSchemaModel::Validator.new('base_event')
+  end
+
+  def respond_to_all?(object, method_names)
+    method_names.all? do |method_name|
+      object.respond_to?(method_name)
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/journaled.rb

@@ -0,0 +1,24 @@
+require "aws-sdk-resources"
+require "delayed_job"
+require "json-schema"
+require "request_store"
+
+require "journaled/engine"
+
+module Journaled
+  mattr_accessor :default_app_name
+
+  def development_or_test?
+    %w(development test).include?(Rails.env)
+  end
+
+  def enabled?
+    !['0', 'false', false, 'f', ''].include?(ENV.fetch('JOURNALED_ENABLED', !development_or_test?))
+  end
+
+  def schema_providers
+    @schema_providers ||= [Journaled::Engine, Rails]
+  end
+
+  module_function :development_or_test?, :enabled?, :schema_providers
+end

data/lib/journaled/engine.rb

@@ -0,0 +1,4 @@
+module Journaled
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/journaled/version.rb

@@ -0,0 +1,3 @@
+module Journaled
+  VERSION = "1.0.0".freeze
+end

metadata

@@ -0,0 +1,238 @@
+--- !ruby/object:Gem::Specification
+name: journaled
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jake Lipson
+- Corey Alexander
+- Cyrus Eslami
+- John Mileham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-resources
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: delayed_job
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: delayed_job_active_record
+  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: pg
+  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: rspec-rails
+  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: rspec_junit_formatter
+  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: rubocop-betterment
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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: webmock
+  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'
+description: A Rails engine to durably deliver schematized events to Amazon Kinesis
+  via DelayedJob.
+email:
+- jacob.lipson@betterment.com
+- corey@betterment.com
+- cyrus@betterment.com
+- john@betterment.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- app/controllers/concerns/journaled/actor.rb
+- app/models/concerns/journaled/changes.rb
+- app/models/journaled/change.rb
+- app/models/journaled/change_definition.rb
+- app/models/journaled/change_writer.rb
+- app/models/journaled/delivery.rb
+- app/models/journaled/event.rb
+- app/models/journaled/job_priority.rb
+- app/models/journaled/json_schema_model/validator.rb
+- app/models/journaled/not_truly_exceptional_error.rb
+- app/models/journaled/writer.rb
+- config/routes.rb
+- lib/journaled.rb
+- lib/journaled/engine.rb
+- lib/journaled/version.rb
+homepage: http://github.com/Betterment/journaled
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- spec/support
+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: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Journaling for Betterment apps.
+test_files: []