journaled 3.1.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d758f3a24c9170a8b7585c330c59a80483ac763640ad847e229f16123d6f9f1b
-  data.tar.gz: adb70f763fd7daffcdc89a02898846a55132461f6329a67d787ce7fd10f73257
+  metadata.gz: 4cefb08a9d7ab294f9084f150f89cda921982fffdb0ec7b0a5bc702ede1d23b8
+  data.tar.gz: 21a484a10c58a3f551e95af064b5f718b9496ba7840ac6c1ac84142b859942db
 SHA512:
-  metadata.gz: 346e26235e8de20fc34e0a888b2d3bf98189d73aaa9968db4af9addcf04b8c8577bb0f8e31d5443d85549f0da6c6defae8f554d328fc328732ae029a90704e2f
-  data.tar.gz: 1be21eed56a1ac95e27e13712831bd45fe0c4e8cf3b896b19e7ad9037b924a9d6543828ddb6d2112cbd25aa77aa464e7e99fd4fd8a4288a89c7d11ad2836915b
+  metadata.gz: 59d07f836a83dde4e4a24a8a5f326ff5cbc7a751d92fb6df66ee22b5b31ac1aa63326675167d45bcd8c572a0e4afeb831774a468eb45097a71c6940a79ce2681
+  data.tar.gz: 807c603b1085819ed003ed8053f81b6fec59ba895c920bc24ac178b0d3188fac554a2ed9b2dcb80ceceb2a26fc5effe6af5d52819f66d041ad7959cfc30957da

data/README.md

@@ -24,16 +24,16 @@ durable, eventually consistent record that discrete events happened.
 [configure ActiveJob](https://guides.rubyonrails.org/active_job_basics.html)
 to use one of the following queue adapters:
 
-- `:delayed_job` (via `delayed_job_active_record`)
-- `:que`
-- `:good_job`
-- `:delayed`
+    - `:delayed_job` (via `delayed_job_active_record`)
+    - `:que`
+    - `:good_job`
+    - `:delayed`
 
-Ensure that your queue adapter is not configured to delete jobs on failure.
+    Ensure that your queue adapter is not configured to delete jobs on failure.
 
-**If you launch your application in production mode and the gem detects that
-`ActiveJob::Base.queue_adapter` is not in the above list, it will raise an exception
-and prevent your application from performing unsafe journaling.**
+    **If you launch your application in production mode and the gem detects that
+    `ActiveJob::Base.queue_adapter` is not in the above list, it will raise an exception
+    and prevent your application from performing unsafe journaling.**
 
 2. To integrate Journaled into your application, simply include the gem in your
 app's Gemfile.
@@ -51,20 +51,21 @@ app's Gemfile.
     require 'journaled/rspec'
     ```
 
-3. You will also need to define the following environment variables to allow Journaled to publish events to your AWS Kinesis event stream:
+3. You will need to set the following config in an initializer to allow Journaled to publish events to your AWS Kinesis event stream:
 
-    * `JOURNALED_STREAM_NAME`
+    ```ruby
+    Journaled.default_stream_name = "my_app_#{Rails.env}_events"
+    ```
 
-    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:
+    You may also define a `#journaled_stream_name` method on `Journaled::Event` instances:
 
     ```ruby
-    Journaled.default_app_name = 'my_app'
-    ```
+    def journaled_stream_name
+      "my_app_#{Rails.env}_alternate_events"
+    end
+    ````
+
+3. You may also need to define environment variables to allow Journaled to publish events to your AWS Kinesis event stream:
 
     You may optionally define the following ENV vars to specify AWS
     credentials outside of the locations that the AWS SDK normally looks:
@@ -82,6 +83,41 @@ app's Gemfile.
 
     The AWS principal whose credentials are in the environment will need to be allowed to assume this role.
 
+### Upgrading from 3.1.0
+
+Versions of Journaled prior to 4.0 relied directly on environment variables for stream names, but now stream names are configured directly.
+When upgrading, you can use the following configuration to maintain the previous behavior:
+
+```ruby
+Journaled.default_stream_name = ENV['JOURNALED_STREAM_NAME']
+```
+
+If you previously specified a `Journaled.default_app_name`, you would have required a more precise environment variable name (substitute `{{upcase_app_name}}`):
+
+```ruby
+Journaled.default_stream_name = ENV["{{upcase_app_name}}_JOURNALED_STREAM_NAME"]
+```
+
+And if you had defined any `journaled_app_name` methods on `Journaled::Event` instances, you can replace them with the following:
+
+```ruby
+def journaled_stream_name
+  ENV['{{upcase_app_name}}_JOURNALED_STREAM_NAME']
+end
+```
+
+When upgrading from 3.1 or below, `Journaled::DeliveryJob` will handle any jobs that remain in the queue by accepting an `app_name` argument. **This behavior will be removed in version 5.0**, so it is recommended to upgrade one major version at a time.
+
+### Upgrading from 2.5.0
+
+Versions of Journaled prior to 3.0 relied direclty on `delayed_job` and a "performable" class called `Journaled::Delivery`.
+In 3.0, this was superceded by an ActiveJob class called `Journaled::DeliveryJob`, but the `Journaled::Delivery` class was not removed until 4.0.
+
+Therefore, when upgrading from 2.5.0 or below, it is recommended to first upgrade to 3.1.0 (to allow any `Journaled::Delivery` jobs to finish working off) before upgrading to 4.0+.
+
+The upgrade to 3.1.0 will require a working ActiveJob config. ActiveJob can be configured globally by setting `ActiveJob::Base.queue_adapter`, or just for Journaled jobs by setting `Journaled::DeliveryJob.queue_adapter`.
+The `:delayed_job` queue adapter will allow you to continue relying on `delayed_job`. You may also consider switching your app(s) to [`delayed`](https://github.com/Betterment/delayed) and using the `:delayed` queue adapter.
+
 ## Usage
 
 ### Configuration

data/app/jobs/journaled/delivery_job.rb

@@ -12,15 +12,24 @@ module Journaled
       raise KinesisTemporaryFailure
     end
 
-    def perform(serialized_event:, partition_key:, app_name:)
+    UNSPECIFIED = Object.new
+    private_constant :UNSPECIFIED
+
+    def perform(serialized_event:, partition_key:, stream_name: UNSPECIFIED, app_name: UNSPECIFIED)
       @serialized_event = serialized_event
       @partition_key = partition_key
-      @app_name = app_name
+      if app_name != UNSPECIFIED
+        @stream_name = self.class.legacy_computed_stream_name(app_name: app_name)
+      elsif stream_name != UNSPECIFIED && !stream_name.nil?
+        @stream_name = stream_name
+      else
+        raise(ArgumentError, 'missing keyword: stream_name')
+      end
 
       journal!
     end
 
-    def self.stream_name(app_name:)
+    def self.legacy_computed_stream_name(app_name:)
       env_var_name = [app_name&.upcase, 'JOURNALED_STREAM_NAME'].compact.join('_')
       ENV.fetch(env_var_name)
     end
@@ -37,7 +46,7 @@ module Journaled
 
     private
 
-    attr_reader :serialized_event, :partition_key, :app_name
+    attr_reader :serialized_event, :partition_key, :stream_name
 
     def journal!
       kinesis_client.put_record record if Journaled.enabled?
@@ -45,7 +54,7 @@ module Journaled
 
     def record
       {
-        stream_name: self.class.stream_name(app_name: app_name),
+        stream_name: stream_name,
         data: serialized_event,
         partition_key: partition_key,
       }

data/app/models/journaled/change.rb

@@ -6,7 +6,7 @@ class Journaled::Change
     :database_operation,
     :logical_operation,
     :changes,
-    :journaled_app_name,
+    :journaled_stream_name,
     :journaled_enqueue_opts,
     :actor
 
@@ -22,7 +22,7 @@ class Journaled::Change
                  database_operation:,
                  logical_operation:,
                  changes:,
-                 journaled_app_name:,
+                 journaled_stream_name:,
                  journaled_enqueue_opts:,
                  actor:)
     @table_name = table_name
@@ -30,7 +30,7 @@ class Journaled::Change
     @database_operation = database_operation
     @logical_operation = logical_operation
     @changes = changes
-    @journaled_app_name = journaled_app_name
+    @journaled_stream_name = journaled_stream_name
     @journaled_enqueue_opts = journaled_enqueue_opts
     @actor = actor
   end

data/app/models/journaled/change_writer.rb

@@ -27,7 +27,7 @@ class Journaled::ChangeWriter
       database_operation: database_operation,
       logical_operation: logical_operation,
       changes: JSON.dump(changes),
-      journaled_app_name: journaled_app_name,
+      journaled_stream_name: journaled_stream_name,
       journaled_enqueue_opts: model.journaled_enqueue_opts,
       actor: actor_uri,
     )
@@ -57,11 +57,11 @@ class Journaled::ChangeWriter
     end
   end
 
-  def journaled_app_name
-    if model.class.respond_to?(:journaled_app_name)
-      model.class.journaled_app_name
+  def journaled_stream_name
+    if model.class.respond_to?(:journaled_stream_name)
+      model.class.journaled_stream_name
     else
-      Journaled.default_app_name
+      Journaled.default_stream_name
     end
   end
 end

data/app/models/journaled/event.rb

@@ -35,8 +35,8 @@ module Journaled::Event
     event_type
   end
 
-  def journaled_app_name
-    Journaled.default_app_name
+  def journaled_stream_name
+    Journaled.default_stream_name
   end
 
   private

data/app/models/journaled/writer.rb

@@ -3,7 +3,7 @@ class Journaled::Writer
     journaled_schema_name
     journaled_partition_key
     journaled_attributes
-    journaled_app_name
+    journaled_stream_name
     journaled_enqueue_opts
   ).freeze
 
@@ -41,7 +41,7 @@ class Journaled::Writer
     {
       serialized_event: serialized_event,
       partition_key: journaled_partition_key,
-      app_name: journaled_app_name,
+      stream_name: journaled_stream_name,
     }
   end
 

data/lib/journaled/version.rb

@@ -1,3 +1,3 @@
 module Journaled
-  VERSION = "3.1.0".freeze
+  VERSION = "4.0.0".freeze
 end

data/lib/journaled.rb

@@ -8,7 +8,7 @@ require "journaled/engine"
 module Journaled
   SUPPORTED_QUEUE_ADAPTERS = %w(delayed delayed_job good_job que).freeze
 
-  mattr_accessor :default_app_name
+  mattr_accessor :default_stream_name
   mattr_accessor(:job_priority) { 20 }
   mattr_accessor(:http_idle_timeout) { 5 }
   mattr_accessor(:http_open_timeout) { 2 }

data/spec/jobs/journaled/delivery_job_spec.rb

@@ -5,11 +5,7 @@ RSpec.describe Journaled::DeliveryJob do
   let(:partition_key) { 'fake_partition_key' }
   let(:serialized_event) { '{"foo":"bar"}' }
   let(:kinesis_client) { Aws::Kinesis::Client.new(stub_responses: true) }
-  let(:args) { { serialized_event: serialized_event, partition_key: partition_key, app_name: nil } }
-
-  around do |example|
-    with_env(JOURNALED_STREAM_NAME: stream_name) { example.run }
-  end
+  let(:args) { { serialized_event: serialized_event, partition_key: partition_key, stream_name: stream_name } }
 
   describe '#perform' do
     let(:return_status_body) { { shard_id: '101', sequence_number: '101123' } }
@@ -19,6 +15,7 @@ RSpec.describe Journaled::DeliveryJob do
       allow(Aws::AssumeRoleCredentials).to receive(:new).and_call_original
       allow(Aws::Kinesis::Client).to receive(:new).and_return kinesis_client
       kinesis_client.stub_responses(:put_record, return_status_body)
+      allow(kinesis_client).to receive(:put_record).and_call_original
 
       allow(Journaled).to receive(:enabled?).and_return(true)
     end
@@ -28,6 +25,11 @@ RSpec.describe Journaled::DeliveryJob do
 
       expect(event.shard_id).to eq '101'
       expect(event.sequence_number).to eq '101123'
+      expect(kinesis_client).to have_received(:put_record).with(
+        stream_name: 'test_events',
+        data: '{"foo":"bar"}',
+        partition_key: 'fake_partition_key',
+      )
     end
 
     context 'when JOURNALED_IAM_ROLE_ARN is defined' do
@@ -68,11 +70,64 @@ RSpec.describe Journaled::DeliveryJob do
       end
     end
 
-    context 'when the stream name env var is NOT set' do
+    context 'when the stream name is not set' do
       let(:stream_name) { nil }
 
       it 'raises an KeyError error' do
-        expect { described_class.perform_now(args) }.to raise_error KeyError
+        expect { described_class.perform_now(args) }.to raise_error ArgumentError, 'missing keyword: stream_name'
+      end
+    end
+
+    unless Gem::Version.new(Journaled::VERSION) < Gem::Version.new('5.0.0')
+      raise <<~MSG
+        Hey! I see that you're bumping the version to 5.0!
+
+        This is a reminder to:
+        - remove the `app_name` argument (and related logic) from `Journaled::DeliveryJob`,
+        - remove the following app_name test contexts, and
+        - make `stream_name` a required kwarg
+
+        Thanks!
+      MSG
+    end
+
+    context 'when the legacy app_name argument is present but nil' do
+      let(:args) { { serialized_event: serialized_event, partition_key: partition_key, app_name: nil } }
+
+      around do |example|
+        with_env(JOURNALED_STREAM_NAME: 'legacy_stream_name') { example.run }
+      end
+
+      it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
+        event = described_class.perform_now(args)
+
+        expect(event.shard_id).to eq '101'
+        expect(event.sequence_number).to eq '101123'
+        expect(kinesis_client).to have_received(:put_record).with(
+          stream_name: 'legacy_stream_name',
+          data: '{"foo":"bar"}',
+          partition_key: 'fake_partition_key',
+        )
+      end
+    end
+
+    context 'when the legacy app_name argument is present and has a value' do
+      let(:args) { { serialized_event: serialized_event, partition_key: partition_key, app_name: 'pied_piper' } }
+
+      around do |example|
+        with_env(PIED_PIPER_JOURNALED_STREAM_NAME: 'pied_piper_events') { example.run }
+      end
+
+      it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
+        event = described_class.perform_now(args)
+
+        expect(event.shard_id).to eq '101'
+        expect(event.sequence_number).to eq '101123'
+        expect(kinesis_client).to have_received(:put_record).with(
+          stream_name: 'pied_piper_events',
+          data: '{"foo":"bar"}',
+          partition_key: 'fake_partition_key',
+        )
       end
     end
 
@@ -137,11 +192,11 @@ RSpec.describe Journaled::DeliveryJob do
     end
   end
 
-  describe ".stream_name" do
+  describe ".legacy_computed_stream_name" do
     context "when app_name is unspecified" do
       it "is fetched from a prefixed ENV var if specified" do
         allow(ENV).to receive(:fetch).and_return("expected_stream_name")
-        expect(described_class.stream_name(app_name: nil)).to eq("expected_stream_name")
+        expect(described_class.legacy_computed_stream_name(app_name: nil)).to eq("expected_stream_name")
         expect(ENV).to have_received(:fetch).with("JOURNALED_STREAM_NAME")
       end
     end
@@ -149,7 +204,7 @@ RSpec.describe Journaled::DeliveryJob do
     context "when app_name is specified" do
       it "is fetched from a prefixed ENV var if specified" do
         allow(ENV).to receive(:fetch).and_return("expected_stream_name")
-        expect(described_class.stream_name(app_name: "my_funky_app_name")).to eq("expected_stream_name")
+        expect(described_class.legacy_computed_stream_name(app_name: "my_funky_app_name")).to eq("expected_stream_name")
         expect(ENV).to have_received(:fetch).with("MY_FUNKY_APP_NAME_JOURNALED_STREAM_NAME")
       end
     end

data/spec/models/journaled/change_writer_spec.rb

@@ -138,30 +138,30 @@ RSpec.describe Journaled::ChangeWriter do
       expect(subject.journaled_change_for("update", {}).logical_operation).to eq("identity_change")
     end
 
-    it "doesn't set journaled_app_name if model class doesn't respond to it" do
-      expect(subject.journaled_change_for("update", {}).journaled_app_name).to eq(nil)
+    it "doesn't set journaled_stream_name if model class doesn't respond to it" do
+      expect(subject.journaled_change_for("update", {}).journaled_stream_name).to eq(nil)
     end
 
     context "with journaled default app name set" do
       around do |example|
-        orig_app_name = Journaled.default_app_name
-        Journaled.default_app_name = "foo"
+        orig_app_name = Journaled.default_stream_name
+        Journaled.default_stream_name = "foo"
         example.run
-        Journaled.default_app_name = orig_app_name
+        Journaled.default_stream_name = orig_app_name
       end
 
       it "passes through default" do
-        expect(subject.journaled_change_for("update", {}).journaled_app_name).to eq("foo")
+        expect(subject.journaled_change_for("update", {}).journaled_stream_name).to eq("foo")
       end
     end
 
-    context "when model class defines journaled_app_name" do
+    context "when model class defines journaled_stream_name" do
       before do
-        allow(model_class).to receive(:journaled_app_name).and_return("my_app")
+        allow(model_class).to receive(:journaled_stream_name).and_return("my_app_events")
       end
 
-      it "sets journaled_app_name if model_class responds to it" do
-        expect(subject.journaled_change_for("update", {}).journaled_app_name).to eq("my_app")
+      it "sets journaled_stream_name if model_class responds to it" do
+        expect(subject.journaled_change_for("update", {}).journaled_stream_name).to eq("my_app_events")
       end
     end
   end

data/spec/models/journaled/event_spec.rb

@@ -65,14 +65,14 @@ RSpec.describe Journaled::Event do
     end
   end
 
-  describe '#journaled_app_name' do
+  describe '#journaled_stream_name' do
     it 'returns nil in the base class so it can be set explicitly in apps spanning multiple app domains' do
-      expect(sample_journaled_event.journaled_app_name).to be_nil
+      expect(sample_journaled_event.journaled_stream_name).to be_nil
     end
 
     it 'returns the journaled default if set' do
-      allow(Journaled).to receive(:default_app_name).and_return("my_app")
-      expect(sample_journaled_event.journaled_app_name).to eq("my_app")
+      allow(Journaled).to receive(:default_stream_name).and_return("my_app_events")
+      expect(sample_journaled_event.journaled_stream_name).to eq("my_app_events")
     end
   end
 

data/spec/models/journaled/writer_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Journaled::Writer do
           journaled_schema_name: nil,
           journaled_attributes: {},
           journaled_partition_key: '',
-          journaled_app_name: nil,
+          journaled_stream_name: nil,
           journaled_enqueue_opts: {},
         )
       end
@@ -34,7 +34,7 @@ RSpec.describe Journaled::Writer do
           journaled_schema_name: :fake_schema_name,
           journaled_attributes: { foo: :bar },
           journaled_partition_key: 'fake_partition_key',
-          journaled_app_name: nil,
+          journaled_stream_name: nil,
           journaled_enqueue_opts: {},
         )
       end
@@ -75,7 +75,7 @@ RSpec.describe Journaled::Writer do
         journaled_schema_name: :fake_schema_name,
         journaled_attributes: journaled_event_attributes,
         journaled_partition_key: 'fake_partition_key',
-        journaled_app_name: 'my_app',
+        journaled_stream_name: 'my_app_events',
         journaled_enqueue_opts: journaled_enqueue_opts,
       )
     end
@@ -104,7 +104,7 @@ RSpec.describe Journaled::Writer do
 
         it 'creates a delivery with the app name passed through' do
           expect { subject.journal! }.to change { enqueued_jobs.count }.from(0).to(1)
-          expect(enqueued_jobs.first[:args].first).to include('app_name' => 'my_app')
+          expect(enqueued_jobs.first[:args].first).to include('stream_name' => 'my_app_events')
         end
 
         context 'when there is no job priority specified in the enqueue opts' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: journaled
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Jake Lipson
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-02 00:00:00.000000000 Z
+date: 2021-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -245,7 +245,6 @@ files:
 - 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/json_schema_model/validator.rb
 - app/models/journaled/not_truly_exceptional_error.rb
@@ -293,7 +292,6 @@ files:
 - spec/models/database_change_protection_spec.rb
 - spec/models/journaled/actor_uri_provider_spec.rb
 - spec/models/journaled/change_writer_spec.rb
-- spec/models/journaled/delivery_spec.rb
 - spec/models/journaled/event_spec.rb
 - spec/models/journaled/json_schema_model/validator_spec.rb
 - spec/models/journaled/writer_spec.rb
@@ -319,7 +317,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Journaling for Betterment apps.
@@ -354,7 +352,6 @@ test_files:
 - spec/dummy/README.rdoc
 - spec/models/journaled/json_schema_model/validator_spec.rb
 - spec/models/journaled/actor_uri_provider_spec.rb
-- spec/models/journaled/delivery_spec.rb
 - spec/models/journaled/event_spec.rb
 - spec/models/journaled/change_writer_spec.rb
 - spec/models/journaled/writer_spec.rb

data/app/models/journaled/delivery.rb

@@ -1,88 +0,0 @@
-class Journaled::Delivery # rubocop:disable Betterment/ActiveJobPerformable
-  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,
-      http_idle_timeout: Journaled.http_idle_timeout,
-      http_open_timeout: Journaled.http_open_timeout,
-      http_read_timeout: Journaled.http_read_timeout,
-    }.merge(credentials)
-  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
-    Aws::Kinesis::Client.new(kinesis_client_config)
-  end
-
-  def credentials
-    if ENV.key?('JOURNALED_IAM_ROLE_ARN')
-      {
-        credentials: iam_assume_role_credentials,
-      }
-    else
-      legacy_credentials_hash_if_present
-    end
-  end
-
-  def legacy_credentials_hash_if_present
-    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
-
-  def sts_client
-    Aws::STS::Client.new({
-      region: ENV.fetch('AWS_DEFAULT_REGION', DEFAULT_REGION),
-    }.merge(legacy_credentials_hash_if_present))
-  end
-
-  def iam_assume_role_credentials
-    @iam_assume_role_credentials ||= Aws::AssumeRoleCredentials.new(
-      client: sts_client,
-      role_arn: ENV.fetch('JOURNALED_IAM_ROLE_ARN'),
-      role_session_name: "JournaledAssumeRoleAccess",
-    )
-  end
-
-  class KinesisTemporaryFailure < ::Journaled::NotTrulyExceptionalError
-  end
-end

data/spec/models/journaled/delivery_spec.rb

@@ -1,222 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Journaled::Delivery do
-  let(:stream_name) { 'test_events' }
-  let(:partition_key) { 'fake_partition_key' }
-  let(:serialized_event) { '{"foo":"bar"}' }
-  let(:kinesis_client) { Aws::Kinesis::Client.new(stub_responses: true) }
-
-  around do |example|
-    with_env(JOURNALED_STREAM_NAME: stream_name) { example.run }
-  end
-
-  subject { described_class.new serialized_event: serialized_event, partition_key: partition_key, app_name: nil }
-
-  describe '#perform' do
-    let(:return_status_body) { { shard_id: '101', sequence_number: '101123' } }
-    let(:return_object) { instance_double Aws::Kinesis::Types::PutRecordOutput, return_status_body }
-
-    before do
-      allow(Aws::AssumeRoleCredentials).to receive(:new).and_call_original
-      allow(Aws::Kinesis::Client).to receive(:new).and_return kinesis_client
-      kinesis_client.stub_responses(:put_record, return_status_body)
-
-      allow(Journaled).to receive(:enabled?).and_return(true)
-    end
-
-    it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
-      event = subject.perform
-
-      expect(event.shard_id).to eq '101'
-      expect(event.sequence_number).to eq '101123'
-    end
-
-    context 'when JOURNALED_IAM_ROLE_ARN is defined' do
-      let(:aws_sts_client) { Aws::STS::Client.new(stub_responses: true) }
-
-      around do |example|
-        with_env(JOURNALED_IAM_ROLE_ARN: 'iam-role-arn-for-assuming-kinesis-access') { example.run }
-      end
-
-      before do
-        allow(Aws::STS::Client).to receive(:new).and_return aws_sts_client
-        aws_sts_client.stub_responses(:assume_role, assume_role_response)
-      end
-
-      let(:assume_role_response) do
-        {
-          assumed_role_user: {
-            arn: 'iam-role-arn-for-assuming-kinesis-access',
-            assumed_role_id: "ARO123EXAMPLE123:Bob",
-          },
-          credentials: {
-            access_key_id: "AKIAIOSFODNN7EXAMPLE",
-            secret_access_key: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYzEXAMPLEKEY",
-            session_token: "EXAMPLEtc764bNrC9SAPBSM22wDOk4x4HIZ8j4FZTwdQWLWsKWHGBuFqwAeMicRXmxfpSPfIeoIYRqTflfKD8YUuwthAx7mSEI",
-            expiration: Time.zone.parse("2011-07-15T23:28:33.359Z"),
-          },
-        }
-      end
-
-      it 'initializes a Kinesis client with assume role credentials' do
-        subject.perform
-
-        expect(Aws::AssumeRoleCredentials).to have_received(:new).with(
-          client: aws_sts_client,
-          role_arn: "iam-role-arn-for-assuming-kinesis-access",
-          role_session_name: "JournaledAssumeRoleAccess",
-        )
-      end
-    end
-
-    context 'when the stream name env var is NOT set' do
-      let(:stream_name) { nil }
-
-      it 'raises an KeyError error' do
-        expect { subject.perform }.to raise_error KeyError
-      end
-    end
-
-    context 'when Amazon responds with an InternalFailure' do
-      before do
-        kinesis_client.stub_responses(:put_record, 'InternalFailure')
-      end
-
-      it 'catches the error and re-raises a subclass of NotTrulyExceptionalError and logs about the failure' do
-        expect(Rails.logger).to receive(:error).with("Kinesis Error - Server Error occurred - Aws::Kinesis::Errors::InternalFailure").once
-        expect { subject.perform }.to raise_error described_class::KinesisTemporaryFailure
-      end
-    end
-
-    context 'when Amazon responds with a ServiceUnavailable' do
-      before do
-        kinesis_client.stub_responses(:put_record, 'ServiceUnavailable')
-      end
-
-      it 'catches the error and re-raises a subclass of NotTrulyExceptionalError and logs about the failure' do
-        allow(Rails.logger).to receive(:error)
-        expect { subject.perform }.to raise_error described_class::KinesisTemporaryFailure
-        expect(Rails.logger).to have_received(:error).with(/\AKinesis Error/).once
-      end
-    end
-
-    context 'when we receive a 504 Gateway timeout' do
-      before do
-        kinesis_client.stub_responses(:put_record, 'Aws::Kinesis::Errors::ServiceError')
-      end
-
-      it 'raises an error that subclasses Aws::Kinesis::Errors::ServiceError' do
-        expect { subject.perform }.to raise_error Aws::Kinesis::Errors::ServiceError
-      end
-    end
-
-    context 'when the IAM user does not have permission to put_record to the specified stream' do
-      before do
-        kinesis_client.stub_responses(:put_record, 'AccessDeniedException')
-      end
-
-      it 'raises an AccessDeniedException error' do
-        expect { subject.perform }.to raise_error Aws::Kinesis::Errors::AccessDeniedException
-      end
-    end
-
-    context 'when the request timesout' do
-      before do
-        kinesis_client.stub_responses(:put_record, Seahorse::Client::NetworkingError.new(Timeout::Error.new))
-      end
-
-      it 'catches the error and re-raises a subclass of NotTrulyExceptionalError and logs about the failure' do
-        expect(Rails.logger).to receive(:error).with(
-          "Kinesis Error - Networking Error occurred - Seahorse::Client::NetworkingError",
-        ).once
-        expect { subject.perform }.to raise_error described_class::KinesisTemporaryFailure
-      end
-    end
-  end
-
-  describe "#stream_name" do
-    context "when app_name is unspecified" do
-      subject { described_class.new serialized_event: serialized_event, partition_key: partition_key, app_name: nil }
-
-      it "is fetched from a prefixed ENV var if specified" do
-        allow(ENV).to receive(:fetch).and_return("expected_stream_name")
-        expect(subject.stream_name).to eq("expected_stream_name")
-        expect(ENV).to have_received(:fetch).with("JOURNALED_STREAM_NAME")
-      end
-    end
-
-    context "when app_name is specified" do
-      subject { described_class.new serialized_event: serialized_event, partition_key: partition_key, app_name: "my_funky_app_name" }
-
-      it "is fetched from a prefixed ENV var if specified" do
-        allow(ENV).to receive(:fetch).and_return("expected_stream_name")
-        expect(subject.stream_name).to eq("expected_stream_name")
-        expect(ENV).to have_received(:fetch).with("MY_FUNKY_APP_NAME_JOURNALED_STREAM_NAME")
-      end
-    end
-  end
-
-  describe "#kinesis_client_config" do
-    it "is in us-east-1 by default" do
-      with_env(AWS_DEFAULT_REGION: nil) do
-        expect(subject.kinesis_client_config).to include(region: 'us-east-1')
-      end
-    end
-
-    it "respects AWS_DEFAULT_REGION env var" do
-      with_env(AWS_DEFAULT_REGION: 'us-west-2') do
-        expect(subject.kinesis_client_config).to include(region: 'us-west-2')
-      end
-    end
-
-    it "doesn't limit retry" do
-      expect(subject.kinesis_client_config).to include(retry_limit: 0)
-    end
-
-    it "provides no AWS credentials by default" do
-      with_env(RUBY_AWS_ACCESS_KEY_ID: nil, RUBY_AWS_SECRET_ACCESS_KEY: nil) do
-        expect(subject.kinesis_client_config).not_to have_key(:access_key_id)
-        expect(subject.kinesis_client_config).not_to have_key(:secret_access_key)
-      end
-    end
-
-    it "will use legacy credentials if specified" do
-      with_env(RUBY_AWS_ACCESS_KEY_ID: 'key_id', RUBY_AWS_SECRET_ACCESS_KEY: 'secret') do
-        expect(subject.kinesis_client_config).to include(access_key_id: 'key_id', secret_access_key: 'secret')
-      end
-    end
-
-    it "will set http_idle_timeout by default" do
-      expect(subject.kinesis_client_config).to include(http_idle_timeout: 5)
-    end
-
-    it "will set http_open_timeout by default" do
-      expect(subject.kinesis_client_config).to include(http_open_timeout: 2)
-    end
-
-    it "will set http_read_timeout by default" do
-      expect(subject.kinesis_client_config).to include(http_read_timeout: 60)
-    end
-
-    context "when Journaled.http_idle_timeout is specified" do
-      it "will set http_idle_timeout by specified value" do
-        allow(Journaled).to receive(:http_idle_timeout).and_return(2)
-        expect(subject.kinesis_client_config).to include(http_idle_timeout: 2)
-      end
-    end
-
-    context "when Journaled.http_open_timeout is specified" do
-      it "will set http_open_timeout by specified value" do
-        allow(Journaled).to receive(:http_open_timeout).and_return(1)
-        expect(subject.kinesis_client_config).to include(http_open_timeout: 1)
-      end
-    end
-
-    context "when Journaled.http_read_timeout is specified" do
-      it "will set http_read_timeout by specified value" do
-        allow(Journaled).to receive(:http_read_timeout).and_return(2)
-        expect(subject.kinesis_client_config).to include(http_read_timeout: 2)
-      end
-    end
-  end
-end