rails_event_store -> ruby_event_store

Author: mostlyobvious

rails_event_store/spec/client_spec.rb

@@ -37,7 +37,7 @@ module RailsEventStore
       client = Client.new(repository: RubyEventStore::InMemoryRepository.new)
 
       received_notifications = 0
-      ActiveSupport::Notifications.subscribe("append_to_stream.repository.rails_event_store") do
+      ActiveSupport::Notifications.subscribe("append_to_stream.repository.ruby_event_store") do
         received_notifications += 1
       end
 
@@ -49,7 +49,7 @@ module RailsEventStore
     specify "wraps mapper into instrumentation" do
       client = Client.new(repository: RubyEventStore::InMemoryRepository.new, mapper: RubyEventStore::Mappers::Default.new)
       received_notifications = 0
-      ActiveSupport::Notifications.subscribe("serialize.mapper.rails_event_store") { received_notifications += 1 }
+      ActiveSupport::Notifications.subscribe("serialize.mapper.ruby_event_store") { received_notifications += 1 }
 
       client.publish(TestEvent.new)
 

ruby_event_store/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -8,7 +8,7 @@ def initialize(dispatcher, instrumentation)
     end
 
     def call(subscriber, event, record)
-      instrumentation.instrument("call.dispatcher.rails_event_store", event: event, subscriber: subscriber) do
+      instrumentation.instrument("call.dispatcher.ruby_event_store", event: event, subscriber: subscriber) do
         dispatcher.call(subscriber, event, record)
       end
     end

ruby_event_store/lib/ruby_event_store/instrumented_repository.rb

@@ -8,43 +8,43 @@ def initialize(repository, instrumentation)
     end
 
     def append_to_stream(records, stream, expected_version)
-      instrumentation.instrument("append_to_stream.repository.rails_event_store", events: records, stream: stream) do
+      instrumentation.instrument("append_to_stream.repository.ruby_event_store", events: records, stream: stream) do
         repository.append_to_stream(records, stream, expected_version)
       end
     end
 
     def link_to_stream(event_ids, stream, expected_version)
-      instrumentation.instrument("link_to_stream.repository.rails_event_store", event_ids: event_ids, stream: stream) do
+      instrumentation.instrument("link_to_stream.repository.ruby_event_store", event_ids: event_ids, stream: stream) do
         repository.link_to_stream(event_ids, stream, expected_version)
       end
     end
 
     def delete_stream(stream)
-      instrumentation.instrument("delete_stream.repository.rails_event_store", stream: stream) do
+      instrumentation.instrument("delete_stream.repository.ruby_event_store", stream: stream) do
         repository.delete_stream(stream)
       end
     end
 
     def read(specification)
-      instrumentation.instrument("read.repository.rails_event_store", specification: specification) do
+      instrumentation.instrument("read.repository.ruby_event_store", specification: specification) do
         repository.read(specification)
       end
     end
 
     def count(specification)
-      instrumentation.instrument("count.repository.rails_event_store", specification: specification) do
+      instrumentation.instrument("count.repository.ruby_event_store", specification: specification) do
         repository.count(specification)
       end
     end
 
     def update_messages(messages)
-      instrumentation.instrument("update_messages.repository.rails_event_store", messages: messages) do
+      instrumentation.instrument("update_messages.repository.ruby_event_store", messages: messages) do
         repository.update_messages(messages)
       end
     end
 
     def streams_of(event_id)
-      instrumentation.instrument("streams_of.repository.rails_event_store", event_id: event_id) do
+      instrumentation.instrument("streams_of.repository.ruby_event_store", event_id: event_id) do
         repository.streams_of(event_id)
       end
     end

ruby_event_store/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -9,13 +9,13 @@ def initialize(mapper, instrumentation)
       end
 
       def event_to_record(event)
-        instrumentation.instrument("serialize.mapper.rails_event_store", domain_event: event) do
+        instrumentation.instrument("serialize.mapper.ruby_event_store", domain_event: event) do
           mapper.event_to_record(event)
         end
       end
 
       def record_to_event(record)
-        instrumentation.instrument("deserialize.mapper.rails_event_store", record: record) do
+        instrumentation.instrument("deserialize.mapper.ruby_event_store", record: record) do
           mapper.record_to_event(record)
         end
       end

ruby_event_store/spec/instrumented_dispatcher_spec.rb

@@ -23,7 +23,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_dispatcher = InstrumentedDispatcher.new(spy, ActiveSupport::Notifications)
-        subscribe_to("call.dispatcher.rails_event_store") do |notification_calls|
+        subscribe_to("call.dispatcher.ruby_event_store") do |notification_calls|
           event = Object.new
           record = Object.new
           subscriber = -> {  }

ruby_event_store/spec/instrumented_repository_spec.rb

@@ -21,7 +21,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_repository = InstrumentedRepository.new(spy, ActiveSupport::Notifications)
-        subscribe_to("append_to_stream.repository.rails_event_store") do |notification_calls|
+        subscribe_to("append_to_stream.repository.ruby_event_store") do |notification_calls|
           instrumented_repository.append_to_stream([record], stream, expected_version)
 
           expect(notification_calls).to eq([{ events: [record], stream: stream }])
@@ -40,7 +40,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_repository = InstrumentedRepository.new(spy, ActiveSupport::Notifications)
-        subscribe_to("link_to_stream.repository.rails_event_store") do |notification_calls|
+        subscribe_to("link_to_stream.repository.ruby_event_store") do |notification_calls|
           instrumented_repository.link_to_stream([event_id], stream, expected_version)
 
           expect(notification_calls).to eq([{ event_ids: [event_id], stream: stream }])
@@ -59,7 +59,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_repository = InstrumentedRepository.new(spy, ActiveSupport::Notifications)
-        subscribe_to("delete_stream.repository.rails_event_store") do |notification_calls|
+        subscribe_to("delete_stream.repository.ruby_event_store") do |notification_calls|
           instrumented_repository.delete_stream("SomeStream")
 
           expect(notification_calls).to eq([{ stream: "SomeStream" }])
@@ -99,7 +99,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_repository = InstrumentedRepository.new(spy, ActiveSupport::Notifications)
-        subscribe_to("read.repository.rails_event_store") do |notification_calls|
+        subscribe_to("read.repository.ruby_event_store") do |notification_calls|
           specification = double
           instrumented_repository.read(specification)
 
@@ -120,7 +120,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_repository = InstrumentedRepository.new(spy, ActiveSupport::Notifications)
-        subscribe_to("count.repository.rails_event_store") do |notification_calls|
+        subscribe_to("count.repository.ruby_event_store") do |notification_calls|
           specification = double
           instrumented_repository.count(specification)
 
@@ -140,7 +140,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_repository = InstrumentedRepository.new(spy, ActiveSupport::Notifications)
-        subscribe_to("update_messages.repository.rails_event_store") do |notification_calls|
+        subscribe_to("update_messages.repository.ruby_event_store") do |notification_calls|
           instrumented_repository.update_messages([record])
 
           expect(notification_calls).to eq([{ messages: [record] }])
@@ -160,7 +160,7 @@ module RubyEventStore
 
       specify "instruments" do
         instrumented_repository = InstrumentedRepository.new(spy, ActiveSupport::Notifications)
-        subscribe_to("streams_of.repository.rails_event_store") do |notification_calls|
+        subscribe_to("streams_of.repository.ruby_event_store") do |notification_calls|
           uuid = SecureRandom.uuid
           instrumented_repository.streams_of(uuid)
 

ruby_event_store/spec/mappers/instrumented_mapper_spec.rb

@@ -20,7 +20,7 @@ module Mappers
 
         specify "instruments" do
           instrumented_mapper = InstrumentedMapper.new(spy, ActiveSupport::Notifications)
-          subscribe_to("serialize.mapper.rails_event_store") do |notification_calls|
+          subscribe_to("serialize.mapper.ruby_event_store") do |notification_calls|
             instrumented_mapper.event_to_record(event)
             expect(notification_calls).to eq([{ domain_event: event }])
           end
@@ -38,7 +38,7 @@ module Mappers
 
         specify "instruments" do
           instrumented_mapper = InstrumentedMapper.new(spy, ActiveSupport::Notifications)
-          subscribe_to("deserialize.mapper.rails_event_store") do |notification_calls|
+          subscribe_to("deserialize.mapper.ruby_event_store") do |notification_calls|
             instrumented_mapper.record_to_event(record)
             expect(notification_calls).to eq([{ record: record }])
           end