coindcx-client 0.1.0

data/docs/standalone_bot.md

@@ -0,0 +1,159 @@
+# Standalone Trading Bot
+
+## Architecture
+
+```
+WS Feed -> Strategy Engine -> Command -> Execution -> Risk -> Exit
+```
+
+## 1. Boot
+
+```ruby
+require 'logger'
+require 'coindcx'
+
+CoinDCX.configure do |config|
+  config.api_key = ENV.fetch('COINDCX_API_KEY')
+  config.api_secret = ENV.fetch('COINDCX_API_SECRET')
+  config.logger = Logger.new($stdout)
+  config.socket_reconnect_attempts = 5
+  config.socket_heartbeat_interval = 10.0
+  config.socket_liveness_timeout = 60.0
+end
+
+client = CoinDCX.client
+ws = client.ws
+```
+
+Keep the event bus in the bot process, not in the gem:
+
+```ruby
+class EventBus
+  def initialize
+    @listeners = Hash.new { |hash, key| hash[key] = [] }
+  end
+
+  def subscribe(event, &block)
+    @listeners[event] << block
+  end
+
+  def publish(event, payload)
+    @listeners[event].each { |listener| listener.call(payload) }
+  end
+end
+
+event_bus = EventBus.new
+```
+
+## 2. Subscribe Market
+
+```ruby
+channel = CoinDCX::WS::PublicChannels.price_stats(pair: 'B-BTC_USDT')
+
+ws.connect
+ws.subscribe_public(channel_name: channel, event_name: 'price-change') do |message|
+  event_bus.publish(:tick, message)
+end
+```
+
+## 3. Strategy Engine
+
+```ruby
+class Strategy
+  def initialize(event_bus:, execution:)
+    @execution = execution
+    event_bus.subscribe(:tick) { |data| on_tick(data) }
+  end
+
+  def on_tick(data)
+    price = BigDecimal(data.fetch('p', data.fetch('last_price')).to_s)
+    execute_trade(price) if breakout?(price)
+  end
+
+  private
+
+  def breakout?(price)
+    price > BigDecimal('100.0')
+  end
+
+  def execute_trade(price)
+    @execution.call(price: price)
+  end
+end
+```
+
+## 4. Execution (Command Pattern in the Bot)
+
+```ruby
+class ExecuteTrade
+  def initialize(client:)
+    @client = client
+  end
+
+  def call(price:)
+    client_order_id = SecureRandom.uuid
+
+    @client.spot.orders.create(
+      side: 'buy',
+      order_type: 'limit_order',
+      market: 'SNTBTC',
+      price_per_unit: price.to_s,
+      total_quantity: 1,
+      client_order_id: client_order_id
+    )
+  end
+end
+```
+
+## 5. Risk Manager
+
+```ruby
+class RiskManager
+  def initialize(entry_price)
+    @entry_price = entry_price
+  end
+
+  def stop_loss
+    @entry_price * BigDecimal('0.98')
+  end
+end
+```
+
+## 6. Exit Logic
+
+```ruby
+risk_manager = RiskManager.new(BigDecimal('100.0'))
+
+event_bus.subscribe(:tick) do |data|
+  price = BigDecimal(data.fetch('p', data.fetch('last_price')).to_s)
+  exit_position if price <= risk_manager.stop_loss
+end
+```
+
+## 7. Resilience
+
+Your bot loop should explicitly handle:
+
+- websocket reconnects
+- duplicate ticks
+- order failures after the gem exhausts its bounded retry policy
+- stale data timeouts
+
+The gem delivers websocket subscriptions with at-least-once semantics after reconnect. Treat duplicate ticks as normal and de-duplicate at your event boundary when your strategy needs exactly-once behavior.
+
+The gem will reconnect sockets, renew private-channel auth, enforce endpoint throttles, and normalize transport errors, but your bot still owns strategy-safe recovery.
+
+Operator intervention is still required when:
+
+- the websocket reaches the `failed` state after bounded reconnect attempts
+- the order circuit breaker opens on repeated create-order failures
+- upstream validation errors indicate your request contract is wrong
+
+## 8. Minimal Loop
+
+```ruby
+execution = ExecuteTrade.new(client: client)
+Strategy.new(event_bus: event_bus, execution: execution)
+
+sleep
+```

data/lib/coindcx/auth/signer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+
+module CoinDCX
+  module Auth
+    class Signer
+      def initialize(api_key:, api_secret:)
+        @api_key = api_key
+        @api_secret = api_secret
+      end
+
+      attr_reader :api_key, :api_secret
+
+      def authenticated_request(body = {})
+        normalized_body = Utils::Payload.compact_hash(body || {})
+        normalized_body[:timestamp] ||= (Time.now.to_f * 1000).floor
+        payload = JSON.generate(Utils::Payload.stringify_keys(normalized_body))
+        [normalized_body, authentication_headers(payload)]
+      end
+
+      def private_channel_join(channel_name: "coindcx")
+        channel = Contracts::ChannelName.validate!(channel_name)
+        payload = JSON.generate("channel" => channel)
+
+        {
+          "channelName" => channel,
+          "authSignature" => signature_for(payload),
+          "apiKey" => api_key
+        }
+      end
+
+      def signature_for(payload)
+        OpenSSL::HMAC.hexdigest("SHA256", api_secret, payload)
+      end
+
+      private
+
+      def authentication_headers(payload)
+        {
+          "X-AUTH-APIKEY" => api_key,
+          "X-AUTH-SIGNATURE" => signature_for(payload)
+        }
+      end
+    end
+  end
+end

data/lib/coindcx/client.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  class Client
+    def initialize(configuration:)
+      @configuration = configuration
+      @http_client = Transport::HttpClient.new(configuration: configuration)
+    end
+
+    attr_reader :configuration
+
+    def public
+      @public ||= REST::Public::Facade.new(http_client: @http_client)
+    end
+
+    def spot
+      @spot ||= REST::Spot::Facade.new(http_client: @http_client)
+    end
+
+    def margin
+      @margin ||= REST::Margin::Facade.new(http_client: @http_client)
+    end
+
+    def user
+      @user ||= REST::User::Facade.new(http_client: @http_client)
+    end
+
+    def transfers
+      @transfers ||= REST::Transfers::Facade.new(http_client: @http_client)
+    end
+
+    def futures
+      @futures ||= REST::Futures::Facade.new(http_client: @http_client)
+    end
+
+    def funding
+      @funding ||= REST::Funding::Facade.new(http_client: @http_client)
+    end
+
+    def ws
+      @ws ||= WS::SocketIOClient.new(configuration: configuration)
+    end
+  end
+end

data/lib/coindcx/configuration.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  class Configuration
+    DEFAULT_API_BASE_URL = "https://api.coindcx.com"
+    DEFAULT_PUBLIC_BASE_URL = "https://public.coindcx.com"
+    DEFAULT_SOCKET_BASE_URL = "wss://stream.coindcx.com"
+    DEFAULT_USER_AGENT = "coindcx-client/#{VERSION}".freeze
+    DEFAULT_PRIVATE_RATE_LIMIT = { limit: 60, period: 60 }.freeze
+    DEFAULT_ENDPOINT_RATE_LIMITS = {
+      # Public (unauthenticated) endpoints — shared bucket keeps burst bursts off the exchange.
+      public_market_data: { limit: 30, period: 1 },
+      public_ticker: { limit: 10, period: 1 },
+      public_order_book: { limit: 10, period: 1 },
+      public_trades: { limit: 10, period: 1 },
+      public_candles: { limit: 10, period: 1 },
+      spot_create_order_multiple: { limit: 2000, period: 60 },
+      spot_create_order: { limit: 2000, period: 60 },
+      spot_cancel_all: { limit: 30, period: 60 },
+      spot_order_status_multiple: { limit: 2000, period: 60 },
+      spot_order_status: { limit: 2000, period: 60 },
+      spot_cancel_multiple_by_id: { limit: 300, period: 60 },
+      spot_cancel_order: { limit: 2000, period: 60 },
+      spot_active_order: { limit: 300, period: 60 },
+      spot_active_order_count: DEFAULT_PRIVATE_RATE_LIMIT,
+      spot_trade_history: DEFAULT_PRIVATE_RATE_LIMIT,
+      spot_edit_price: { limit: 2000, period: 60 },
+      futures_list_orders: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_create_order: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_cancel_order: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_edit_order: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_list: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_update_leverage: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_add_margin: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_remove_margin: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_cancel_all_open_orders: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_cancel_all_open_orders_for_position: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_exit: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_create_tpsl: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_transactions: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_cross_margin_details: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_positions_margin_type: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_wallet_transfer: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_wallet_details: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_wallet_transactions: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_trades: DEFAULT_PRIVATE_RATE_LIMIT,
+      futures_instrument_detail: DEFAULT_PRIVATE_RATE_LIMIT,
+      funding_fetch_orders: DEFAULT_PRIVATE_RATE_LIMIT,
+      funding_lend: DEFAULT_PRIVATE_RATE_LIMIT,
+      funding_settle: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_create_order: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_list_orders: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_fetch_order: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_cancel_order: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_exit_order: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_edit_target: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_edit_stop_loss: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_edit_trailing_stop_loss: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_edit_target_order_price: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_add_margin: DEFAULT_PRIVATE_RATE_LIMIT,
+      margin_remove_margin: DEFAULT_PRIVATE_RATE_LIMIT,
+      user_balances: DEFAULT_PRIVATE_RATE_LIMIT,
+      user_info: DEFAULT_PRIVATE_RATE_LIMIT,
+      wallets_transfer: DEFAULT_PRIVATE_RATE_LIMIT,
+      wallets_sub_account_transfer: DEFAULT_PRIVATE_RATE_LIMIT
+    }.freeze
+
+    attr_accessor :api_key, :api_secret, :api_base_url, :public_base_url,
+                  :socket_base_url, :socket_io_connect_options, :open_timeout, :read_timeout, :max_retries,
+                  :retry_base_interval, :user_agent, :socket_io_backend_factory,
+                  :endpoint_rate_limits, :logger, :socket_reconnect_attempts,
+                  :socket_reconnect_interval, :socket_heartbeat_interval,
+                  :socket_liveness_timeout, :market_data_retry_budget,
+                  :private_read_retry_budget, :idempotent_order_retry_budget,
+                  :circuit_breaker_threshold, :circuit_breaker_cooldown
+
+    # rubocop:disable Metrics/MethodLength
+    def initialize
+      @api_base_url = DEFAULT_API_BASE_URL
+      @public_base_url = DEFAULT_PUBLIC_BASE_URL
+      @socket_base_url = DEFAULT_SOCKET_BASE_URL
+      # CoinDCX stream matches official socket.io-client 2.x (Engine.IO v3). The default backend
+      # `socket.io-client-simple` only parses that protocol; `EIO: 4` breaks the handshake/payloads.
+      @socket_io_connect_options = { EIO: 3 }
+      @open_timeout = 5
+      @read_timeout = 30
+      @max_retries = 2
+      @retry_base_interval = 0.25
+      @user_agent = DEFAULT_USER_AGENT
+      @endpoint_rate_limits = DEFAULT_ENDPOINT_RATE_LIMITS.transform_values(&:dup)
+      @logger = nil
+      @socket_reconnect_attempts = 5
+      @socket_reconnect_interval = 1.0
+      @socket_heartbeat_interval = 10.0
+      @socket_liveness_timeout = 60.0
+      @market_data_retry_budget = 2
+      @private_read_retry_budget = 1
+      @idempotent_order_retry_budget = 1
+      @circuit_breaker_threshold = 3
+      @circuit_breaker_cooldown = 30.0
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def rate_limit_for(bucket_name)
+      endpoint_rate_limits[bucket_name.to_sym]
+    end
+  end
+end

data/lib/coindcx/contracts/channel_name.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Contracts
+    module ChannelName
+      module_function
+
+      def validate!(channel_name)
+        normalized_channel_name = channel_name.to_s.strip
+        raise Errors::ValidationError, "channel_name must be provided" if normalized_channel_name.empty?
+        return normalized_channel_name if valid_format?(normalized_channel_name)
+
+        raise Errors::ValidationError, "channel_name must match a CoinDCX channel name"
+      end
+
+      def valid_format?(channel_name)
+        channel_name == "coindcx" ||
+          channel_name.include?("@") ||
+          channel_name.include?("_")
+      end
+    end
+  end
+end

data/lib/coindcx/contracts/identifiers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Contracts
+    module Identifiers
+      MARKET_PATTERN = /\A[A-Z0-9]+\z/
+      PAIR_PATTERN = /\A[A-Z]+-[A-Z0-9]+_[A-Z0-9]+\z/
+      CURRENCY_PATTERN = /\A[A-Z0-9]+\z/
+
+      module_function
+
+      def validate_market!(market)
+        validate!(market, MARKET_PATTERN, "market must be a CoinDCX symbol like SNTBTC")
+      end
+
+      def validate_pair!(pair)
+        validate!(pair, PAIR_PATTERN, "pair must be a CoinDCX pair like B-BTC_USDT")
+      end
+
+      def validate_instrument!(instrument)
+        validate_pair!(instrument)
+      end
+
+      def validate_currency!(currency)
+        validate!(currency, CURRENCY_PATTERN, "currency_short_name must be a CoinDCX currency code")
+      end
+
+      def validate!(value, pattern, message)
+        string_value = value.to_s.strip
+        raise Errors::ValidationError, message if string_value.empty? || string_value.match?(pattern) == false
+
+        string_value
+      end
+    end
+  end
+end

data/lib/coindcx/contracts/order_request.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Contracts
+    module OrderRequest
+      VALID_SIDES = %w[buy sell].freeze
+      VALID_SPOT_ORDER_TYPES = %w[market_order limit_order stop_limit take_profit].freeze
+      VALID_MARGIN_ORDER_TYPES = %w[market_order limit_order stop_limit take_profit].freeze
+      IDEMPOTENCY_KEYS = %i[client_order_id clientOrderId].freeze
+
+      module_function
+
+      def validate_spot_create!(attributes)
+        validate_side!(attributes)
+        validate_order_type!(attributes, VALID_SPOT_ORDER_TYPES)
+        validate_market!(attributes)
+        validate_positive_quantity!(attributes, :total_quantity)
+        validate_positive_number!(attributes, :price_per_unit) if present?(attributes, :price_per_unit)
+        validate_idempotency_key!(attributes)
+        attributes
+      end
+
+      def validate_spot_create_many!(orders)
+        Array(orders).each { |order| validate_spot_create!(order) }
+        orders
+      end
+
+      def validate_futures_create!(attributes)
+        validate_side!(attributes)
+        validate_pair!(attributes, :pair) if present?(attributes, :pair)
+        validate_pair!(attributes, :instrument) if present?(attributes, :instrument)
+        validate_positive_quantity!(attributes, :quantity, :size, :total_quantity)
+        validate_idempotency_key!(attributes)
+        attributes
+      end
+
+      def validate_margin_create!(attributes)
+        validate_side!(attributes)
+        validate_order_type!(attributes, VALID_MARGIN_ORDER_TYPES)
+        validate_market!(attributes)
+        validate_positive_quantity!(attributes, :quantity, :total_quantity)
+        validate_positive_number!(attributes, :price_per_unit) if present?(attributes, :price_per_unit)
+        validate_idempotency_key!(attributes)
+        attributes
+      end
+
+      def validate_idempotency_key!(attributes)
+        IDEMPOTENCY_KEYS.each do |key|
+          value = fetch_optional(attributes, key)
+          return value if value && !value.to_s.strip.empty?
+        end
+
+        raise Errors::ValidationError, "client_order_id is required for order placement safety"
+      end
+
+      def validate_side!(attributes)
+        side = fetch_required(attributes, :side)
+        return side if VALID_SIDES.include?(side.to_s)
+
+        raise Errors::ValidationError, "side must be one of: #{VALID_SIDES.join(', ')}"
+      end
+
+      def validate_positive_quantity!(attributes, *keys)
+        quantity = fetch_quantity(attributes, keys)
+        return quantity if quantity.to_f.positive?
+
+        raise Errors::ValidationError, "#{keys.join(' or ')} must be greater than 0"
+      end
+
+      def validate_positive_number!(attributes, key)
+        value = fetch_required(attributes, key)
+        return value if value.to_f.positive?
+
+        raise Errors::ValidationError, "#{key} must be greater than 0"
+      end
+
+      def validate_order_type!(attributes, valid_order_types)
+        order_type = fetch_required(attributes, :order_type)
+        return order_type if valid_order_types.include?(order_type.to_s)
+
+        raise Errors::ValidationError, "order_type must be one of: #{valid_order_types.join(', ')}"
+      end
+
+      def validate_market!(attributes)
+        Identifiers.validate_market!(fetch_required(attributes, :market))
+      end
+
+      def validate_pair!(attributes, key)
+        Identifiers.validate_pair!(fetch_required(attributes, key))
+      end
+
+      def fetch_quantity(attributes, keys)
+        keys.each do |key|
+          value = fetch_optional(attributes, key)
+          return value unless value.nil?
+        end
+
+        raise Errors::ValidationError, "#{keys.join(' or ')} is required"
+      end
+
+      def fetch_required(attributes, key)
+        value = fetch_optional(attributes, key)
+        return value unless value.nil?
+
+        raise Errors::ValidationError, "#{key} is required"
+      end
+
+      def fetch_optional(attributes, key)
+        return attributes[key] if attributes.key?(key)
+        return attributes[key.to_s] if attributes.key?(key.to_s)
+
+        nil
+      end
+
+      def present?(attributes, key)
+        !fetch_optional(attributes, key).nil?
+      end
+    end
+  end
+end

data/lib/coindcx/contracts/socket_backend.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Contracts
+    module SocketBackend
+      REQUIRED_METHODS = %i[connect start_transport! emit on disconnect].freeze
+
+      module_function
+
+      def validate!(backend)
+        missing_methods = REQUIRED_METHODS.reject { |method_name| backend.respond_to?(method_name) }
+        return backend if missing_methods.empty?
+
+        raise Errors::ConfigurationError,
+              "socket backend must respond to #{REQUIRED_METHODS.join(', ')}; missing #{missing_methods.join(', ')}"
+      end
+    end
+  end
+end

data/lib/coindcx/contracts/wallet_transfer_request.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Contracts
+    module WalletTransferRequest
+      VALID_WALLET_TYPES = %w[spot futures margin].freeze
+
+      module_function
+
+      def validate_transfer!(attributes)
+        validate_wallet_type!(attributes, :source_wallet_type)
+        validate_wallet_type!(attributes, :destination_wallet_type)
+        validate_positive_number!(attributes, :amount)
+        validate_currency!(attributes, :currency_short_name)
+        attributes
+      end
+
+      def validate_wallet_type!(attributes, key)
+        wallet_type = fetch_required(attributes, key)
+        return wallet_type if VALID_WALLET_TYPES.include?(wallet_type.to_s)
+
+        raise Errors::ValidationError, "#{key} must be one of: #{VALID_WALLET_TYPES.join(', ')}"
+      end
+
+      def validate_positive_number!(attributes, key)
+        number = fetch_required(attributes, key)
+        return number if number.to_f.positive?
+
+        raise Errors::ValidationError, "#{key} must be greater than 0"
+      end
+
+      def validate_currency!(attributes, key)
+        Identifiers.validate_currency!(fetch_required(attributes, key))
+      end
+
+      def fetch_required(attributes, key)
+        return attributes[key] if attributes.key?(key)
+        return attributes[key.to_s] if attributes.key?(key.to_s)
+
+        raise Errors::ValidationError, "#{key} is required"
+      end
+
+      private_class_method :validate_wallet_type!, :validate_positive_number!, :validate_currency!, :fetch_required
+    end
+  end
+end

data/lib/coindcx/errors/base_error.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Errors
+    class Error < StandardError
+      attr_reader :category, :code, :request_context, :retryable
+
+      def initialize(message, category: nil, code: nil, request_context: nil, retryable: false)
+        super(message)
+        @category = category
+        @code = code
+        @request_context = request_context
+        @retryable = retryable
+      end
+    end
+
+    class ConfigurationError < Error; end
+    class ValidationError < Error; end
+    class MissingDependencyError < Error; end
+
+    class SocketError < Error; end
+    class SocketConnectionError < SocketError; end
+    class SocketAuthenticationError < SocketError; end
+    class SocketStateError < SocketError; end
+    class SocketHeartbeatTimeoutError < SocketError; end
+
+    class ApiError < Error
+      attr_reader :status, :body, :retry_after
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(message, status: nil, body: nil, category: nil, code: nil, request_context: nil, retryable: false, retry_after: nil)
+        super(message, category: category, code: code, request_context: request_context, retryable: retryable)
+        @status = status
+        @body = body
+        @retry_after = retry_after
+      end
+      # rubocop:enable Metrics/ParameterLists
+    end
+
+    class RequestError < ApiError; end
+    class RateLimitError < ApiError; end
+    class AuthError < ApiError; end
+    class RemoteValidationError < RequestError; end
+    class TransportError < RequestError; end
+    class UpstreamServerError < RequestError; end
+    class RetryableRateLimitError < RateLimitError; end
+    class CircuitOpenError < RequestError; end
+
+    AuthenticationError = AuthError
+    # Semantic aliases used in documentation and consumer code.
+    NetworkError = TransportError
+    ExchangeError = UpstreamServerError
+  end
+end

data/lib/coindcx/logging/null_logger.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Logging
+    class NullLogger
+      def debug(*) = nil
+      def info(*) = nil
+      def warn(*) = nil
+      def error(*) = nil
+    end
+  end
+end

data/lib/coindcx/logging/structured_logger.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Logging
+    module StructuredLogger
+      module_function
+
+      def log(logger, level, payload)
+        return unless logger.respond_to?(level)
+
+        logger.public_send(level, payload)
+      rescue ArgumentError, TypeError
+        logger.public_send(level, payload.inspect)
+      end
+    end
+  end
+end