artery 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 143083385171dd538fca23bf7be5e9294aca001ac387186f7e75362a85d28683
-  data.tar.gz: a87a4dcdd579ebca3be40eb0ea73db8272c10a9abd8534327ea0ccc28ab9353f
+  metadata.gz: 4f1a11d03719b7ed31e9defaab67715e12d45a94bf44d6ef006487345aac4620
+  data.tar.gz: 8c7293da3839b5da9867b106a8a49c55ecab34aced06c79020ef09e9f8ccdef9
 SHA512:
-  metadata.gz: 5198b675ce6edda582da79999247a75f0f571afb8513887e1820a3d028b55da0ebe8a5451f64b1b896a81b6c4c8f8314af7ef7a0a8fd5f9fbc0a8ff0bae2d18d
-  data.tar.gz: c149bf5eca05b0086a878722ef6ff77a344e637988aca0af1ee15508f87d11782abcbc91498d75e5c91972b35b55c3bc83b633568d9e831c3a8a456d593c37cb
+  metadata.gz: eefc0283414fed7b76b869ee6fd5e78d0e755b31f294364d691df36fb840807401c6e883f9cc3da2e7606d2eb239364b582162e71d3aec6f53a782541e38cff9
+  data.tar.gz: 225827156bb7a3f6db5e1dd90beb5bb1b62d35b9761098f0101f56ed679dda10e978b504b4c5f4a856b90591db455fbdf563ecccd700474115d1e3cd7cfcb071

data/README.md

@@ -36,6 +36,82 @@ mount Artery::Engine => '/artery'
 ```
 And then you can access it by url `http(s)://{ your_app_url }/artery/`.
 
+## Logging
+
+Artery uses `ActiveSupport::Notifications` for instrumentation and `ActiveSupport::TaggedLogging` for request-scoped log tagging.
+
+### Configuration
+
+```ruby
+Artery.configure do |config|
+  config.service_name = :my_service
+
+  # Log every message (publish/request/subscribe/response).
+  # When false, only lifecycle events (errors, sync, connect/disconnect) are logged.
+  # Default: true
+  config.log_messages = true
+
+  # Maximum bytes of message body included in logs.
+  # nil = no limit (full dumps). Default: nil
+  config.message_body_max_size = 1024
+end
+```
+
+### Log levels
+
+| Level | What is logged |
+|-------|----------------|
+| `debug` | Message payloads (request, publish, received, response), skip reasons, sync page details |
+| `info` | Lifecycle events: backend connected/reconnected, worker started, sync started/completed |
+| `warn` | Backend disconnected, request errors, no subscriptions defined |
+| `error` | Exception handling (via `ErrorHandler`/`SentryErrorHandler`) |
+
+### Request-scoped tagging
+
+All logs emitted during message processing are automatically tagged with the request ID (`reply_to` or a generated hex ID). This includes nested operations (enrich, sub-requests) and any Rails logs (e.g., ActiveRecord queries) that go through the shared logger:
+
+```
+[Artery] [Worker] [abc123] [INBOX.xyz789] [RECV] <svc.model.update> {"uuid":"..."}
+[Artery] [Worker] [abc123] [INBOX.xyz789]   Source Load (0.5ms)  SELECT ...
+[Artery] [Worker] [abc123] [INBOX.xyz789] [DONE] <svc.model.update> (12.3ms)
+```
+
+On Rails 7.0+ with `config.active_support.isolation_level = :fiber`, this tagging is fiber-safe.
+
+### Instrumentation events
+
+All events follow the `event_name.artery` convention. You can subscribe to them for metrics, tracing, or custom logging:
+
+```ruby
+ActiveSupport::Notifications.subscribe('request.artery') do |event|
+  StatsD.measure('artery.request', event.duration, tags: { route: event.payload[:route] })
+end
+```
+
+Available events (each uses a `stage:`, `state:`, or `action:` payload key to distinguish sub-stages):
+
+| Event | Key | Values | Other payload | Description |
+|-------|-----|--------|---------------|-------------|
+| `request.artery` | `stage` | `:sent` | `route`, `data` | Outbound request sent |
+| | | `:response` | `route`, `data` | Response received |
+| | | `:error` | `route`, `error` | Request timeout or error (always logged) |
+| `publish.artery` | — | — | `route`, `data` | Fire-and-forget publish |
+| `message.artery` | `stage` | `:received` | `route`, `data`, `request_id` | Incoming message |
+| | | `:handled` | `route`, `request_id` | Finished processing (block, has duration) |
+| | | `:skipped` | `reason` | Message skipped |
+| `sync.artery` | `stage` | `:receive_all` | `route` | Full sync (block, has duration) |
+| | | `:receive_updates` | `route` | Incremental sync (block, has duration) |
+| | | `:page` | `route`, `page` | Page received |
+| | | `:continue` | — | Not all updates received, continuing |
+| `connection.artery` | `state` | `:connected` | `server` | Connected to backend |
+| | | `:disconnected` | — | Disconnected from backend |
+| | | `:reconnected` | `server` | Reconnected to backend |
+| | | `:closed` | — | Connection closed |
+| `worker.artery` | `action` | `:started` | `worker_id` | Worker started |
+| | | `:subscribing` | `route` | Subscribing to route |
+| `lock.artery` | `state` | `:waiting` | `latest_index` | Waiting for subscription lock |
+| | | `:acquired` | `latest_index` | Lock acquired |
+
 ## Contributing
 Contribution directions go here.
 

data/db/migrate/20250320120000_create_artery_model_infos.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class CreateArteryModelInfos < ActiveRecord::Migration[5.2]
+  def up
+    create_table :artery_model_infos do |t|
+      t.string :model, null: false
+      t.bigint :latest_index, null: false, default: 0
+    end
+
+    add_index :artery_model_infos, :model, unique: true
+
+    execute <<~SQL.squish
+      INSERT INTO artery_model_infos (model, latest_index)
+      SELECT model, COALESCE(MAX(id), 0)
+      FROM artery_messages
+      GROUP BY model
+    SQL
+  end
+
+  def down
+    drop_table :artery_model_infos
+  end
+end

data/lib/artery/active_record/message.rb

@@ -10,6 +10,9 @@ module Artery
       serialize :data, coder: JSON
 
       after_commit :send_to_artery, on: :create
+      around_create :lock_on_model
+
+      attr_accessor :cached_previous_index
 
       alias index id
 
@@ -20,7 +23,7 @@ module Artery
         end
 
         def latest_index(model)
-          where(model: model).last&.id.to_i
+          Artery.model_info_class.find_by(model: model)&.latest_index.to_i
         end
 
         def delete_old
@@ -29,13 +32,23 @@ module Artery
         end
       end
 
-      # It is used in after_commit, so we always know previous index based on our current index
       def previous_index
+        return cached_previous_index if cached_previous_index
+
         scope = self.class.where(model: model).order(:id)
         scope = scope.where(self.class.arel_table[:id].lt(index)) if index
 
         scope.select(:id).last&.id.to_i
       end
+
+      private
+
+      def lock_on_model
+        lock_row = Artery.model_info_class.acquire_lock!(model)
+        self.cached_previous_index = lock_row.latest_index
+        yield
+        lock_row.update!(latest_index: id)
+      end
     end
   end
 end

data/lib/artery/active_record/model_info.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Artery
+  module ActiveRecord
+    class ModelInfo < ::ActiveRecord::Base
+      self.table_name = 'artery_model_infos'
+
+      def self.acquire_lock!(model_name)
+        lock_row = lock('FOR UPDATE').find_by(model: model_name)
+        return lock_row if lock_row
+
+        begin
+          create!(model: model_name, latest_index: Artery.message_class.latest_index(model_name))
+        rescue ::ActiveRecord::RecordNotUnique
+          # concurrent insert — fine
+        end
+
+        lock('FOR UPDATE').find_by!(model: model_name)
+      end
+    end
+  end
+end

data/lib/artery/active_record/subscription_info.rb

@@ -23,11 +23,11 @@ module Artery
       def with_lock
         self.class.transaction do
           unless (was_locked = @locked) # prevent double lock to reduce selects
-            Artery.logger.debug "WAITING FOR LOCK...  [LATEST_INDEX: #{latest_index}]"
+            Artery::Instrumentation.instrument(:lock, state: :waiting, latest_index: latest_index)
 
-            reload lock: true # explicitely reload record
-
-            Artery.logger.debug "GOT LOCK! [LATEST_INDEX: #{latest_index}]"
+            Artery::Instrumentation.instrument(:lock, state: :acquired, latest_index: latest_index) do
+              reload lock: true # explicitely reload record
+            end
 
             @locked = true
           end

data/lib/artery/active_record.rb

@@ -3,6 +3,7 @@
 module Artery
   module ActiveRecord
     autoload :Message,          'artery/active_record/message'
+    autoload :ModelInfo,        'artery/active_record/model_info'
     autoload :SubscriptionInfo, 'artery/active_record/subscription_info'
   end
 end

data/lib/artery/backend.rb

@@ -58,14 +58,18 @@ module Artery
         yield(handler)
 
         data ||= {}
-        Artery.logger.debug "REQUESTED: <#{uri.to_route}> #{data.to_json}"
+        Artery::Instrumentation.instrument(:request, stage: :sent, route: uri.to_route, data: data)
 
+        request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         backend.request(uri.to_route, data.to_json, options) do |message|
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start) * 1000
           if message.is_a?(Error) # timeout case
-            Artery.logger.debug "REQUEST ERROR: <#{uri.to_route}> #{message.message}"
+            Artery::Instrumentation.instrument(:request, stage: :error, route: uri.to_route,
+                                                         error: message.message, duration_ms: duration_ms)
             handler.call :error, message
           else
-            Artery.logger.debug "REQUEST RESPONSE: <#{uri.to_route}> #{message}"
+            Artery::Instrumentation.instrument(:request, stage: :response, route: uri.to_route,
+                                                         data: message, duration_ms: duration_ms)
             begin
               message ||= '{}'
               response = JSON.parse(message).with_indifferent_access
@@ -89,7 +93,7 @@ module Artery
 
       def publish(route, data)
         backend.publish(route, data.to_json)
-        Artery.logger.debug "PUBLISHED: <#{route}> #{data.to_json}"
+        Artery::Instrumentation.instrument(:publish, route: route, data: data)
       end
     end
   end

data/lib/artery/backends/nats_pure.rb

@@ -16,20 +16,20 @@ module Artery
           client = ::NATS.connect(options)
 
           client.on_reconnect do
-            Artery.logger.debug "Reconnected to server at #{client.connected_server}"
+            Artery::Instrumentation.instrument(:connection, state: :reconnected, server: client.connected_server)
           end
 
           client.on_disconnect do
-            Artery.logger.debug 'Disconnected!'
+            Artery::Instrumentation.instrument(:connection, state: :disconnected)
           end
 
           client.on_close do
-            Artery.logger.debug 'Connection to NATS closed'
+            Artery::Instrumentation.instrument(:connection, state: :closed)
           end
           client
         end
 
-        Artery.logger.debug "Connected to #{@client.connected_server}"
+        Artery::Instrumentation.instrument(:connection, state: :connected, server: @client.connected_server)
         @client.connect unless @client.connected?
 
         @client

data/lib/artery/check.rb

@@ -31,18 +31,17 @@ module Artery
     end
 
     def self.run(services)
-      Artery.logger.push_tags('Check')
-      result = Artery::Check.new.execute services
-
-      errors = result.select { |_service, res| res[:status] == :error }
-      return if errors.blank?
-
-      Artery.logger.error "There were errors:\n\t#{errors.map do |service, result|
-        "#{service}: #{result[:message]}"
-      end.join("\n\t")}"
-      exit 1
-    ensure
-      Artery.logger.pop_tags
+      Artery.logger.tagged('Check') do
+        result = Artery::Check.new.execute services
+
+        errors = result.select { |_service, res| res[:status] == :error }
+        return if errors.blank?
+
+        Artery.logger.error "There were errors:\n\t#{errors.map do |service, res|
+          "#{service}: #{res[:message]}"
+        end.join("\n\t")}"
+        exit 1
+      end
     end
   end
 end

data/lib/artery/config.rb

@@ -6,14 +6,18 @@ module Artery
 
     included do # rubocop:disable Metrics/BlockLength
       class << self
-        attr_accessor :message_class, :subscription_info_class, :service_name, :backend_config, :request_timeout,
-                      :error_handler
+        attr_accessor :message_class, :model_info_class, :subscription_info_class, :service_name, :backend_config,
+                      :request_timeout, :error_handler
 
         # Ability to redefine message class (for example, for non-activerecord applications)
         def message_class
           @message_class || get_model_class(:Message)
         end
 
+        def model_info_class
+          @model_info_class || get_model_class(:ModelInfo)
+        end
+
         def subscription_info_class
           @subscription_info_class || get_model_class(:SubscriptionInfo)
         end
@@ -35,6 +39,16 @@ module Artery
           @request_timeout || ENV.fetch('ARTERY_REQUEST_TIMEOUT', '15').to_i
         end
 
+        attr_writer :log_messages, :message_body_max_size
+
+        def log_messages?
+          instance_variable_defined?(:@log_messages) ? @log_messages : true
+        end
+
+        def message_body_max_size
+          instance_variable_defined?(:@message_body_max_size) ? @message_body_max_size : nil
+        end
+
         def error_handler
           @error_handler || (defined?(Artery::SentryErrorHandler) ? Artery::SentryErrorHandler : Artery::ErrorHandler)
         end

data/lib/artery/instrumentation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Artery
+  module Instrumentation
+    NAMESPACE = 'artery'
+
+    module_function
+
+    def instrument(event, payload = {}, &block)
+      ActiveSupport::Notifications.instrument("#{event}.#{NAMESPACE}", payload, &block)
+    end
+  end
+end

data/lib/artery/log_subscriber.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Artery
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def request(event)
+      p = event.payload
+
+      case p[:stage]
+      when :sent     then debug "[REQ] <#{p[:route]}> #{truncate_body(p[:data])}"
+      when :response then debug "[RESP] <#{p[:route]}> #{truncate_body(p[:data])} (#{p[:duration_ms].round(1)}ms)"
+      when :error    then warn "[REQ ERR] <#{p[:route]}> #{p[:error]} (#{p[:duration_ms].round(1)}ms)"
+      end
+    end
+
+    def publish(event)
+      debug "[PUB] <#{event.payload[:route]}> #{truncate_body(event.payload[:data])}"
+    end
+
+    def message(event)
+      p = event.payload
+
+      case p[:stage]
+      when :received then debug "[RECV] <#{p[:route]}> #{truncate_body(p[:data])}"
+      when :handled  then debug "[DONE] <#{p[:route]}> (#{event.duration.round(1)}ms)"
+      when :skipped  then debug "[SKIP] #{p[:reason]}"
+      end
+    end
+
+    def sync(event)
+      p = event.payload
+
+      case p[:stage]
+      when :receive_all     then info "[SYNC] receive_all <#{p[:route]}> (#{event.duration.round(1)}ms)"
+      when :receive_updates then info "[SYNC] receive_updates <#{p[:route]}> (#{event.duration.round(1)}ms)"
+      when :page            then debug "[SYNC] page #{p[:page]} received for <#{p[:route]}>"
+      when :continue        then debug '[SYNC] not all updates received, continuing...'
+      end
+    end
+
+    def connection(event)
+      p = event.payload
+
+      case p[:state]
+      when :connected    then info "[Backend] connected to #{p[:server]}"
+      when :disconnected then warn '[Backend] disconnected'
+      when :reconnected  then info "[Backend] reconnected to #{p[:server]}"
+      when :closed       then info '[Backend] connection closed'
+      end
+    end
+
+    def worker(event)
+      p = event.payload
+
+      case p[:action]
+      when :started     then info "started (id=#{p[:worker_id]})"
+      when :subscribing then debug "[SUB] <#{p[:route]}>"
+      end
+    end
+
+    def lock(event)
+      p = event.payload
+
+      case p[:state]
+      when :waiting  then debug "[LOCK] waiting (latest_index: #{p[:latest_index]})"
+      when :acquired then debug "[LOCK] acquired (latest_index: #{p[:latest_index]}, #{event.duration.round(1)}ms)"
+      end
+    end
+
+    private
+
+    def debug(msg)
+      return unless Artery.log_messages?
+
+      super
+    end
+
+    def truncate_body(data)
+      return '' if data.nil?
+
+      json = data.is_a?(String) ? data : data.to_json
+      max = Artery.message_body_max_size
+      return json if max.nil? || max <= 0 || json.length <= max
+
+      "#{json[0...max]}... (truncated, #{json.length} bytes total)"
+    end
+
+    def logger
+      Artery.logger
+    end
+  end
+end
+
+Artery::LogSubscriber.attach_to :artery

data/lib/artery/model/callbacks.rb

@@ -14,26 +14,42 @@ module Artery
           after_archive   :artery_on_archive
           after_unarchive :artery_on_unarchive
         end
+
+        before_commit :artery_send_pending_notifications
       end
 
       def artery_on_create
-        artery_notify_message(:create)
+        artery_pending_notifications << [:create]
       end
 
       def artery_on_update
-        artery_notify_message(:update)
+        artery_pending_notifications << [:update]
       end
 
       def artery_on_archive
-        artery_notify_message(:archive, archived_at: archived_at.to_f)
+        artery_pending_notifications << [:archive, { archived_at: archived_at.to_f }]
       end
 
       def artery_on_unarchive
-        artery_notify_message(:unarchive)
+        artery_pending_notifications << [:unarchive]
       end
 
       def artery_on_destroy
-        artery_notify_message(:delete)
+        artery_pending_notifications << [:delete]
+      end
+
+      private
+
+      def artery_pending_notifications
+        @artery_pending_notifications ||= []
+      end
+
+      def artery_send_pending_notifications
+        artery_pending_notifications.each do |action, extra_data|
+          artery_notify_message(action, extra_data || {})
+        end
+      ensure
+        @artery_pending_notifications = nil
       end
     end
   end

data/lib/artery/model/subscriptions.rb

@@ -53,8 +53,7 @@ module Artery
 
         # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def artery_add_get_subscriptions
-          artery_add_subscription Routing.uri(model: artery_model_name_plural, action: :get) do |data, reply, sub|
-            Artery.logger.info "HEY-HEY-HEY, message on GET with arguments: `#{[data, reply, sub].inspect}`!"
+          artery_add_subscription Routing.uri(model: artery_model_name_plural, action: :get) do |data, reply, _sub|
             obj = artery_find data['uuid']
 
             representation = data['representation']
@@ -64,9 +63,7 @@ module Artery
             Artery.publish(reply, data)
           end
 
-          artery_add_subscription Routing.uri(model: artery_model_name_plural, action: :get_all) do |data, reply, sub|
-            Artery.logger.info "HEY-HEY-HEY, message on GET_ALL with arguments: `#{[data, reply, sub].inspect}`!"
-
+          artery_add_subscription Routing.uri(model: artery_model_name_plural, action: :get_all) do |data, reply, _sub|
             scope    = "artery_#{data['scope'] || 'all'}"
             per_page = data['per_page']
             page     = data['page'] || 0
@@ -90,9 +87,7 @@ module Artery
           end
 
           artery_add_subscription Routing.uri(model: artery_model_name_plural,
-                                              action: :get_updates) do |data, reply, sub|
-            Artery.logger.info "HEY-HEY-HEY, message on GET_UPDATES with arguments: `#{[data, reply, sub].inspect}`!"
-
+                                              action: :get_updates) do |data, reply, _sub|
             index = data['after_index'].to_i
             autoenrich = data['representation'].present?
             per_page = data['per_page'] || (autoenrich ? ARTERY_MAX_AUTOENRICHED_UPDATES_SYNC : ARTERY_MAX_UPDATES_SYNC)
@@ -112,8 +107,6 @@ module Artery
             latest_index = Artery.message_class.latest_index(artery_model_name)
             updates_latest_index = messages.last&.index || latest_index
 
-            Artery.logger.info "MESSAGES: #{messages.inspect}"
-
             # Autoenrich data
             if autoenrich
               scope = "artery_#{data['scope'] || 'all'}"

data/lib/artery/subscription/synchronization.rb

@@ -83,14 +83,18 @@ module Artery
       def receive_all
         synchronization_in_progress! unless synchronization_in_progress?
 
-        reset_latest_index!
-        while receive_all_once == :continue; end
+        Artery::Instrumentation.instrument(:sync, stage: :receive_all, route: uri.to_route) do
+          reset_latest_index!
+          while receive_all_once == :continue; end
+        end
       end
 
       def receive_updates
         synchronization_in_progress!
 
-        while receive_updates_once == :continue; end
+        Artery::Instrumentation.instrument(:sync, stage: :receive_updates, route: uri.to_route) do
+          while receive_updates_once == :continue; end
+        end
       end
 
       private
@@ -128,15 +132,13 @@ module Artery
 
         Artery.request all_uri.to_route, all_data do |on|
           on.success do |data|
-            Artery.logger.debug "HEY-HEY, ALL OBJECTS: <#{all_uri.to_route}> #{[data].inspect}"
-
             objects = data[:objects].map(&:with_indifferent_access)
 
             synchronization_transaction { handler.call(:synchronization, objects, page) }
 
             if synchronization_per_page && objects.any?
               synchronization_page_update!(page)
-              Artery.logger.debug "PAGE #{page} RECEIVED, WILL CONTINUE..."
+              Artery::Instrumentation.instrument(:sync, stage: :page, route: all_uri.to_route, page: page)
               should_continue = true
             else
               synchronization_page_update!(nil) if synchronization_per_page
@@ -184,8 +186,6 @@ module Artery
 
         Artery.request updates_uri.to_route, updates_data do |on|
           on.success do |data|
-            Artery.logger.debug "HEY-HEY, LAST_UPDATES: <#{updates_uri.to_route}> #{[data].inspect}"
-
             updates = data[:updates].map(&:with_indifferent_access)
             synchronization_transaction do
               updates.sort_by { |u| u[:_index] }.each do |update|
@@ -197,7 +197,7 @@ module Artery
             end
 
             if data[:_continue]
-              Artery.logger.debug 'NOT ALL UPDATES RECEIVED, WILL CONTINUE...'
+              Artery::Instrumentation.instrument(:sync, stage: :continue)
               should_continue = true
             else
               synchronization_in_progress!(false)

data/lib/artery/subscription.rb

@@ -60,39 +60,43 @@ module Artery
     end
 
     def handle(message) # rubocop:disable Metrics/AbcSize
-      Artery.logger.push_tags message.reply
-      Artery.logger.debug "GOT MESSAGE: #{message.inspect}"
-
-      info.lock_for_message(message) do
-        if !message.from_updates? && synchronization_in_progress?
-          Artery.logger.debug 'SKIPPING MESSAGE RECEIVED WHILE SYNC IN PROGRESS'
-          return
-        end
-        return if !message.from_updates? && !validate_index(message)
+      request_id = message.reply || SecureRandom.hex(8)
+      Artery.logger.tagged(request_id) do
+        Artery::Instrumentation.instrument(
+          :message, stage: :received, route: message.from, data: message.data, request_id: request_id
+        )
+
+        info.lock_for_message(message) do
+          if !message.from_updates? && synchronization_in_progress?
+            Artery::Instrumentation.instrument(:message, stage: :skipped, reason: 'sync in progress')
+            return
+          end
+          return if !message.from_updates? && !validate_index(message)
 
-        if message.update_by_us?
-          Artery.logger.debug 'SKIPPING UPDATE MADE BY US'
-          update_info_by_message!(message)
-          return
-        end
+          if message.update_by_us?
+            Artery::Instrumentation.instrument(:message, stage: :skipped, reason: 'update by us')
+            update_info_by_message!(message)
+            return
+          end
 
-        unless handler.has_block?(message.action) || handler.has_block?(:_default)
-          Artery.logger.debug 'SKIPPING MESSAGE WE ARE NOT LISTENING TO'
-          update_info_by_message!(message)
-          return
-        end
+          unless handler.has_block?(message.action) || handler.has_block?(:_default)
+            Artery::Instrumentation.instrument(:message, stage: :skipped, reason: 'no listener for action')
+            update_info_by_message!(message)
+            return
+          end
 
-        case message.action
-        when :create, :update
-          message.enrich_data do |attributes|
-            handle_data(message, attributes)
+          Artery::Instrumentation.instrument(:message, stage: :handled, route: message.from, request_id: request_id) do
+            case message.action
+            when :create, :update
+              message.enrich_data do |attributes|
+                handle_data(message, attributes)
+              end
+            else
+              handle_data(message)
+            end
           end
-        else
-          handle_data(message)
         end
       end
-    ensure
-      Artery.logger.pop_tags
     end
 
     protected
@@ -101,13 +105,11 @@ module Artery
       return true unless message.previous_index.positive? && latest_message_index.positive?
 
       if message.previous_index > latest_message_index
-        Artery.logger.debug 'WE\'VE GOT FUTURE MESSAGE, REQUESTING ALL MISSED'
-
-        synchronize! # this will include current message
+        Artery::Instrumentation.instrument(:message, stage: :skipped, reason: 'future message, requesting missed')
+        synchronize!
         false
       elsif message.previous_index < latest_message_index
-        Artery.logger.debug 'WE\'VE GOT PREVIOUS MESSAGE AND ALREADY HANDLED IT, SKIPPING'
-
+        Artery::Instrumentation.instrument(:message, stage: :skipped, reason: 'duplicate message, already handled')
         false
       else
         true
@@ -118,8 +120,8 @@ module Artery
       data ||= message.data
 
       info.lock_for_message(message) do
-        if data == :not_found # special data when enrich failed with not_found
-          Artery.logger.debug 'SKIP HANDLING MESSAGE BECAUSE ENRICH DATA IS BLANK'
+        if data == :not_found
+          Artery::Instrumentation.instrument(:message, stage: :skipped, reason: 'enrich data not found')
         else
           handler.call(:_before_action, message.action, data, message.reply, message.from)
 

data/lib/artery/sync.rb

@@ -25,11 +25,11 @@ module Artery
 
     def self.run(subscriptions)
       sync_id = SecureRandom.hex
-      Artery.logger.push_tags('Sync', sync_id)
-      Artery::Sync.new(sync_id).execute subscriptions
-    ensure
-      Artery.clear_synchronizing_subscriptions!
-      Artery.logger.pop_tags
+      Artery.logger.tagged('Sync', sync_id) do
+        Artery::Sync.new(sync_id).execute subscriptions
+      ensure
+        Artery.clear_synchronizing_subscriptions!
+      end
     end
   end
 end

data/lib/artery/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Artery
-  VERSION = '1.2.2'
+  VERSION = '1.3.0'
 end

data/lib/artery/worker.rb

@@ -37,38 +37,40 @@ module Artery
     private
 
     def worker_cycle(services, subscriptions_on_services)
-      Artery.logger.push_tags 'Worker', worker_id
-      tries = 0
-      begin
-        subscribe_healthz
-
-        @sync.execute services
-
-        subscriptions_on_services.each do |uri, subscriptions|
-          Artery.logger.debug "Subscribing on '#{uri}'"
-          Artery.subscribe uri.to_route, queue: "#{Artery.service_name}.worker" do |data, reply, from|
-            subscriptions.each do |subscription|
-              message = Subscription::IncomingMessage.new subscription, data, reply, from
-
-              subscription.handle(message)
-            rescue StandardError => e
-              Artery.handle_error Error.new("Error in subscription handling: #{e.inspect}",
-                                            original_exception: e,
-                                            subscription: {
-                                              subscriber: subscription.subscriber.to_s,
-                                              route: from,
-                                              data: data.to_json
-                                            })
+      Artery.logger.tagged('Worker', worker_id) do
+        Artery::Instrumentation.instrument(:worker, action: :started, worker_id: worker_id)
+        tries = 0
+        begin
+          subscribe_healthz
+
+          @sync.execute services
+
+          subscriptions_on_services.each do |uri, subscriptions|
+            Artery::Instrumentation.instrument(:worker, action: :subscribing, route: uri.to_s)
+            Artery.subscribe uri.to_route, queue: "#{Artery.service_name}.worker" do |data, reply, from|
+              subscriptions.each do |subscription|
+                message = Subscription::IncomingMessage.new subscription, data, reply, from
+
+                subscription.handle(message)
+              rescue StandardError => e
+                Artery.handle_error Error.new("Error in subscription handling: #{e.inspect}",
+                                              original_exception: e,
+                                              subscription: {
+                                                subscriber: subscription.subscriber.to_s,
+                                                route: from,
+                                                data: data.to_json
+                                              })
+              end
             end
           end
-        end
-      rescue StandardError => e
-        tries += 1
+        rescue StandardError => e
+          tries += 1
 
-        Artery.handle_error Error.new("WORKER ERROR: #{e.inspect}", original_exception: e)
-        retry if tries <= 5
+          Artery.handle_error Error.new("WORKER ERROR: #{e.inspect}", original_exception: e)
+          retry if tries <= 5
 
-        Artery.handle_error Error.new('Worker failed 5 times and exited.')
+          Artery.handle_error Error.new('Worker failed 5 times and exited.')
+        end
       end
     end
   end

data/lib/artery.rb

@@ -4,6 +4,8 @@ require_relative 'artery/engine' if defined?(Rails)
 
 require_relative 'artery/errors'
 require_relative 'artery/backends/base'
+require_relative 'artery/instrumentation'
+require_relative 'artery/log_subscriber'
 
 require 'multiblock'
 require_relative 'multiblock_has_block'
@@ -44,7 +46,7 @@ module Artery
     def handle_signals
       %w[TERM INT].each do |sig|
         trap(sig) do
-          puts "Caught #{sig} signal, exiting..."
+          Artery.logger.info "Caught #{sig} signal, exiting..."
 
           yield if block_given?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: artery
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Sergey Gnuskov
@@ -100,6 +100,7 @@ files:
 - db/migrate/20200109120304_add_index_on_model_to_artery_messages.rb
 - db/migrate/20200109120305_remove_last_message_at_from_artery_subscription_infos.rb
 - db/migrate/20240411120304_add_synchronization_heartbeat_to_artery_subscription_infos.rb
+- db/migrate/20250320120000_create_artery_model_infos.rb
 - exe/artery-check
 - exe/artery-clean
 - exe/artery-sync
@@ -107,6 +108,7 @@ files:
 - lib/artery.rb
 - lib/artery/active_record.rb
 - lib/artery/active_record/message.rb
+- lib/artery/active_record/model_info.rb
 - lib/artery/active_record/subscription_info.rb
 - lib/artery/backend.rb
 - lib/artery/backends/base.rb
@@ -117,6 +119,8 @@ files:
 - lib/artery/engine.rb
 - lib/artery/errors.rb
 - lib/artery/healthz_subscription.rb
+- lib/artery/instrumentation.rb
+- lib/artery/log_subscriber.rb
 - lib/artery/model.rb
 - lib/artery/model/callbacks.rb
 - lib/artery/model/subscriptions.rb