class WaterDrop::Instrumentation::LoggerListener

def debug(event, log_message)
  @logger.debug("[#{event[:producer_id]}] #{log_message}")
end

def error(event, log_message)
  @logger.error("[#{event[:producer_id]}] #{log_message}")
end

def info(event, log_message)
  @logger.info("[#{event[:producer_id]}] #{log_message} took #{event[:time]} ms")
end

def initialize(logger, log_messages: true)
  @logger = logger
  @log_messages = log_messages
end

def log_messages?
  @log_messages
end

def on_buffer_flushed_async(event)
  messages = event[:messages]
  info(event, "Async flushing of #{messages.size} messages from the buffer")
  return unless log_messages?
  debug(event, messages)
end

def on_buffer_flushed_sync(event)
  messages = event[:messages]
  info(event, "Sync flushing of #{messages.size} messages from the buffer")
  return unless log_messages?
  debug(event, messages)
end

def on_buffer_purged(event)
  info(event, 'Successfully purging buffer')
end

def on_error_occurred(event)
  error = event[:error]
  type = event[:type]
  error(event, "Error occurred: #{error} - #{type}")
end

def on_message_buffered(event)
  message = event[:message]
  info(event, "Buffering of a message to '#{message[:topic]}' topic")
  return unless log_messages?
  debug(event, [message])
end

def on_message_produced_async(event)
  message = event[:message]
  info(event, "Async producing of a message to '#{message[:topic]}' topic")
  return unless log_messages?
  debug(event, message)
end

def on_message_produced_sync(event)
  message = event[:message]
  info(event, "Sync producing of a message to '#{message[:topic]}' topic")
  return unless log_messages?
  debug(event, message)
end

def on_messages_buffered(event)
  messages = event[:messages]
  info(event, "Buffering of #{messages.size} messages")
  return unless log_messages?
  debug(event, [messages, messages.size])
end

def on_messages_produced_async(event)
  messages = event[:messages]
  topics_count = messages.map { |message| "'#{message[:topic]}'" }.uniq.count
  info(event, "Async producing of #{messages.size} messages to #{topics_count} topics")
  return unless log_messages?
  debug(event, messages)
end

def on_messages_produced_sync(event)
  messages = event[:messages]
  topics_count = messages.map { |message| "'#{message[:topic]}'" }.uniq.count
  info(event, "Sync producing of #{messages.size} messages to #{topics_count} topics")
  return unless log_messages?
  debug(event, messages)
end

def on_producer_closed(event)
  info(event, 'Closing producer')
end

def on_transaction_aborted(event)
  info(event, 'Aborting transaction')
end

def on_transaction_committed(event)
  info(event, 'Committing transaction')
end

def on_transaction_finished(event)
  info(event, 'Processing transaction')
end

def on_transaction_started(event)
  info(event, 'Starting transaction')
end