activemerchant 1.45.0 → 1.126.0

data/lib/active_merchant/connection.rb

@@ -0,0 +1,196 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'benchmark'
+
+module ActiveMerchant
+  class Connection
+    using NetHttpSslConnection
+    include NetworkConnectionRetries
+
+    MAX_RETRIES = 3
+    OPEN_TIMEOUT = 60
+    READ_TIMEOUT = 60
+    VERIFY_PEER = true
+    CA_FILE = File.expand_path('../certs/cacert.pem', File.dirname(__FILE__))
+    CA_PATH = nil
+    MIN_VERSION = :TLS1_1
+    RETRY_SAFE = false
+    RUBY_184_POST_HEADERS = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+
+    attr_accessor :endpoint
+    attr_accessor :open_timeout
+    attr_accessor :read_timeout
+    attr_accessor :verify_peer
+    attr_accessor :ssl_version
+    if Net::HTTP.instance_methods.include?(:min_version=)
+      attr_accessor :min_version
+      attr_accessor :max_version
+    end
+    attr_reader :ssl_connection
+    attr_accessor :ca_file
+    attr_accessor :ca_path
+    attr_accessor :pem
+    attr_accessor :pem_password
+    attr_reader :wiredump_device
+    attr_accessor :logger
+    attr_accessor :tag
+    attr_accessor :ignore_http_status
+    attr_accessor :max_retries
+    attr_accessor :proxy_address
+    attr_accessor :proxy_port
+
+    def initialize(endpoint)
+      @endpoint     = endpoint.is_a?(URI) ? endpoint : URI.parse(endpoint)
+      @open_timeout = OPEN_TIMEOUT
+      @read_timeout = READ_TIMEOUT
+      @retry_safe   = RETRY_SAFE
+      @verify_peer  = VERIFY_PEER
+      @ca_file      = CA_FILE
+      @ca_path      = CA_PATH
+      @max_retries  = MAX_RETRIES
+      @ignore_http_status = false
+      @ssl_version = nil
+      if Net::HTTP.instance_methods.include?(:min_version=)
+        @min_version = MIN_VERSION
+        @max_version = nil
+      end
+      @ssl_connection = {}
+      @proxy_address = :ENV
+      @proxy_port = nil
+    end
+
+    def wiredump_device=(device)
+      raise ArgumentError, "can't wiredump to frozen #{device.class}" if device&.frozen?
+
+      @wiredump_device = device
+    end
+
+    def request(method, body, headers = {})
+      request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      headers = headers.dup
+      headers['connection'] ||= 'close'
+
+      retry_exceptions(max_retries: max_retries, logger: logger, tag: tag) do
+        info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
+
+        result = nil
+
+        realtime = Benchmark.realtime do
+          http.start unless http.started?
+          @ssl_connection = http.ssl_connection
+          info "connection_ssl_version=#{ssl_connection[:version]} connection_ssl_cipher=#{ssl_connection[:cipher]}", tag
+
+          result =
+            case method
+            when :get
+              raise ArgumentError, 'GET requests do not support a request body' if body
+
+              http.get(endpoint.request_uri, headers)
+            when :post
+              debug body
+              http.post(endpoint.request_uri, body, RUBY_184_POST_HEADERS.merge(headers))
+            when :put
+              debug body
+              http.put(endpoint.request_uri, body, headers)
+            when :patch
+              debug body
+              http.patch(endpoint.request_uri, body, headers)
+            when :delete
+              # It's kind of ambiguous whether the RFC allows bodies
+              # for DELETE requests. But Net::HTTP's delete method
+              # very unambiguously does not.
+              if body
+                debug body
+                req = Net::HTTP::Delete.new(endpoint.request_uri, headers)
+                req.body = body
+                http.request(req)
+              else
+                http.delete(endpoint.request_uri, headers)
+              end
+            else
+              raise ArgumentError, "Unsupported request method #{method.to_s.upcase}"
+            end
+        end
+
+        info '--> %d %s (%d %.4fs)' % [result.code, result.message, result.body ? result.body.length : 0, realtime], tag
+        debug result.body
+        result
+      end
+    ensure
+      info 'connection_request_total_time=%.4fs' % [Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start], tag
+      http.finish if http.started?
+    end
+
+    private
+
+    def http
+      @http ||= begin
+        http = Net::HTTP.new(endpoint.host, endpoint.port, proxy_address, proxy_port)
+        configure_debugging(http)
+        configure_timeouts(http)
+        configure_ssl(http)
+        configure_cert(http)
+        http
+      end
+    end
+
+    def configure_debugging(http)
+      http.set_debug_output(wiredump_device)
+    end
+
+    def configure_timeouts(http)
+      http.open_timeout = open_timeout
+      http.read_timeout = read_timeout
+    end
+
+    def configure_ssl(http)
+      return unless endpoint.scheme == 'https'
+
+      http.use_ssl = true
+      http.ssl_version = ssl_version if ssl_version
+      if http.respond_to?(:min_version=)
+        http.min_version = min_version if min_version
+        http.max_version = max_version if max_version
+      end
+
+      if verify_peer
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.ca_file     = ca_file
+        http.ca_path     = ca_path
+      else
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
+    def configure_cert(http)
+      return if pem.blank?
+
+      http.cert = OpenSSL::X509::Certificate.new(pem)
+
+      if pem_password
+        http.key = OpenSSL::PKey::RSA.new(pem, pem_password)
+      else
+        http.key = OpenSSL::PKey::RSA.new(pem)
+      end
+    end
+
+    def debug(message, tag = nil)
+      log(:debug, message, tag)
+    end
+
+    def info(message, tag = nil)
+      log(:info, message, tag)
+    end
+
+    def error(message, tag = nil)
+      log(:error, message, tag)
+    end
+
+    def log(level, message, tag)
+      message = "[#{tag}] #{message}" if tag
+      logger&.send(level, message)
+    end
+  end
+end

data/lib/active_merchant/country.rb

@@ -39,11 +39,11 @@ module ActiveMerchant #:nodoc:
 
     def initialize(options = {})
       @name = options.delete(:name)
-      @codes = options.collect{|k,v| CountryCode.new(v)}
+      @codes = options.collect { |_k, v| CountryCode.new(v) }
     end
 
     def code(format)
-      @codes.detect{|c| c.format == format}
+      @codes.detect { |c| c.format == format }
     end
 
     def ==(other)
@@ -72,6 +72,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'AD', name: 'Andorra', alpha3: 'AND', numeric: '020' },
       { alpha2: 'AO', name: 'Angola', alpha3: 'AGO', numeric: '024' },
       { alpha2: 'AI', name: 'Anguilla', alpha3: 'AIA', numeric: '660' },
+      { alpha2: 'AQ', name: 'Antarctica', alpha3: 'ATA', numeric: '010' },
       { alpha2: 'AG', name: 'Antigua and Barbuda', alpha3: 'ATG', numeric: '028' },
       { alpha2: 'AR', name: 'Argentina', alpha3: 'ARG', numeric: '032' },
       { alpha2: 'AM', name: 'Armenia', alpha3: 'ARM', numeric: '051' },
@@ -90,6 +91,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'BM', name: 'Bermuda', alpha3: 'BMU', numeric: '060' },
       { alpha2: 'BT', name: 'Bhutan', alpha3: 'BTN', numeric: '064' },
       { alpha2: 'BO', name: 'Bolivia', alpha3: 'BOL', numeric: '068' },
+      { alpha2: 'BQ', name: 'Bonaire, Sint Eustatius and Saba', alpha3: 'BES', numeric: '535' },
       { alpha2: 'BA', name: 'Bosnia and Herzegovina', alpha3: 'BIH', numeric: '070' },
       { alpha2: 'BW', name: 'Botswana', alpha3: 'BWA', numeric: '072' },
       { alpha2: 'BV', name: 'Bouvet Island', alpha3: 'BVD', numeric: '074' },
@@ -181,7 +183,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'KI', name: 'Kiribati', alpha3: 'KIR', numeric: '296' },
       { alpha2: 'KP', name: 'Korea, Democratic People\'s Republic of', alpha3: 'PRK', numeric: '408' },
       { alpha2: 'KR', name: 'Korea, Republic of', alpha3: 'KOR', numeric: '410' },
-      { alpha2: 'KV', name: 'Kosovo', alpha3: 'KSV', numeric: '377' },
+      { alpha2: 'XK', name: 'Kosovo', alpha3: 'XKX', numeric: '900' },
       { alpha2: 'KW', name: 'Kuwait', alpha3: 'KWT', numeric: '414' },
       { alpha2: 'KG', name: 'Kyrgyzstan', alpha3: 'KGZ', numeric: '417' },
       { alpha2: 'LA', name: 'Lao People\'s Democratic Republic', alpha3: 'LAO', numeric: '418' },
@@ -220,7 +222,6 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'NR', name: 'Nauru', alpha3: 'NRU', numeric: '520' },
       { alpha2: 'NP', name: 'Nepal', alpha3: 'NPL', numeric: '524' },
       { alpha2: 'NL', name: 'Netherlands', alpha3: 'NLD', numeric: '528' },
-      { alpha2: 'AN', name: 'Netherlands Antilles', alpha3: 'ANT', numeric: '530' },
       { alpha2: 'NC', name: 'New Caledonia', alpha3: 'NCL', numeric: '540' },
       { alpha2: 'NZ', name: 'New Zealand', alpha3: 'NZL', numeric: '554' },
       { alpha2: 'NI', name: 'Nicaragua', alpha3: 'NIC', numeric: '558' },
@@ -245,6 +246,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'PR', name: 'Puerto Rico', alpha3: 'PRI', numeric: '630' },
       { alpha2: 'QA', name: 'Qatar', alpha3: 'QAT', numeric: '634' },
       { alpha2: 'RE', name: 'Reunion', alpha3: 'REU', numeric: '638' },
+      { alpha2: 'RO', name: 'Romania', alpha3: 'ROU', numeric: '642' },
       { alpha2: 'RO', name: 'Romania', alpha3: 'ROM', numeric: '642' },
       { alpha2: 'RU', name: 'Russian Federation', alpha3: 'RUS', numeric: '643' },
       { alpha2: 'RW', name: 'Rwanda', alpha3: 'RWA', numeric: '646' },
@@ -264,15 +266,17 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'SC', name: 'Seychelles', alpha3: 'SYC', numeric: '690' },
       { alpha2: 'SL', name: 'Sierra Leone', alpha3: 'SLE', numeric: '694' },
       { alpha2: 'SG', name: 'Singapore', alpha3: 'SGP', numeric: '702' },
+      { alpha2: 'SX', name: 'Sint Maarten', alpha3: 'SXM', numeric: '534' },
       { alpha2: 'SK', name: 'Slovakia', alpha3: 'SVK', numeric: '703' },
       { alpha2: 'SI', name: 'Slovenia', alpha3: 'SVN', numeric: '705' },
       { alpha2: 'SB', name: 'Solomon Islands', alpha3: 'SLB', numeric: '090' },
       { alpha2: 'SO', name: 'Somalia', alpha3: 'SOM', numeric: '706' },
       { alpha2: 'ZA', name: 'South Africa', alpha3: 'ZAF', numeric: '710' },
       { alpha2: 'GS', name: 'South Georgia and the South Sandwich Islands', alpha3: 'SGS', numeric: '239' },
+      { alpha2: 'SS', name: 'South Sudan', alpha3: 'SSD', numeric: '728' },
       { alpha2: 'ES', name: 'Spain', alpha3: 'ESP', numeric: '724' },
       { alpha2: 'LK', name: 'Sri Lanka', alpha3: 'LKA', numeric: '144' },
-      { alpha2: 'SD', name: 'Sudan', alpha3: 'SDN', numeric: '736' },
+      { alpha2: 'SD', name: 'Sudan', alpha3: 'SDN', numeric: '729' },
       { alpha2: 'SR', name: 'Suriname', alpha3: 'SUR', numeric: '740' },
       { alpha2: 'SJ', name: 'Svalbard and Jan Mayen', alpha3: 'SJM', numeric: '744' },
       { alpha2: 'SZ', name: 'Swaziland', alpha3: 'SWZ', numeric: '748' },
@@ -315,17 +319,18 @@ module ActiveMerchant #:nodoc:
     ]
 
     def self.find(name)
-      raise InvalidCountryCodeError, "Cannot lookup country for an empty name" if name.blank?
+      raise InvalidCountryCodeError, 'Cannot lookup country for an empty name' if name.blank?
 
       case name.length
       when 2, 3
         upcase_name = name.upcase
         country_code = CountryCode.new(name)
-        country = COUNTRIES.detect{|c| c[country_code.format] == upcase_name }
+        country = COUNTRIES.detect { |c| c[country_code.format] == upcase_name }
       else
-        country = COUNTRIES.detect{|c| c[:name] == name }
+        country = COUNTRIES.detect { |c| c[:name].casecmp(name).zero? }
       end
       raise InvalidCountryCodeError, "No country could be found for the country #{name}" if country.nil?
+
       Country.new(country.dup)
     end
   end

data/lib/active_merchant/errors.rb

@@ -3,6 +3,12 @@ module ActiveMerchant #:nodoc:
   end
 
   class ConnectionError < ActiveMerchantError # :nodoc:
+    attr_reader :triggering_exception
+
+    def initialize(message, triggering_exception)
+      super(message)
+      @triggering_exception = triggering_exception
+    end
   end
 
   class RetriableConnectionError < ConnectionError # :nodoc:

data/lib/active_merchant/net_http_ssl_connection.rb

@@ -0,0 +1,11 @@
+require 'net/http'
+
+module NetHttpSslConnection
+  refine Net::HTTP do
+    def ssl_connection
+      return {} unless use_ssl? && @socket.present?
+
+      { version: @socket.io.ssl_version, cipher: @socket.io.cipher[0] }
+    end
+  end
+end

data/lib/active_merchant/network_connection_retries.rb

@@ -0,0 +1,78 @@
+require 'openssl'
+
+module ActiveMerchant
+  module NetworkConnectionRetries
+    DEFAULT_RETRIES = 3
+    DEFAULT_CONNECTION_ERRORS = {
+      EOFError               => 'The remote server dropped the connection',
+      Errno::ECONNRESET      => 'The remote server reset the connection',
+      Timeout::Error         => 'The connection to the remote server timed out',
+      Errno::ETIMEDOUT       => 'The connection to the remote server timed out',
+      SocketError            => 'The connection to the remote server could not be established',
+      Errno::EHOSTUNREACH    => 'The connection to the remote server could not be established',
+      OpenSSL::SSL::SSLError => 'The SSL connection to the remote server could not be established'
+    }
+
+    def self.included(base)
+      base.send(:attr_accessor, :retry_safe)
+    end
+
+    def retry_exceptions(options = {})
+      connection_errors = DEFAULT_CONNECTION_ERRORS.merge(options[:connection_exceptions] || {})
+
+      retry_network_exceptions(options) do
+        yield
+      rescue Errno::ECONNREFUSED => e
+        raise ActiveMerchant::RetriableConnectionError.new('The remote server refused the connection', e)
+      rescue OpenSSL::X509::CertificateError => e
+        NetworkConnectionRetries.log(options[:logger], :error, e.message, options[:tag])
+        raise ActiveMerchant::ClientCertificateError, 'The remote server did not accept the provided SSL certificate'
+      rescue Zlib::BufError
+        raise ActiveMerchant::InvalidResponseError, 'The remote server replied with an invalid response'
+      rescue *connection_errors.keys => e
+        raise ActiveMerchant::ConnectionError.new(derived_error_message(connection_errors, e.class), e)
+      end
+    end
+
+    def self.log(logger, level, message, tag = nil)
+      tag ||= self.class.to_s
+      message = "[#{tag}] #{message}"
+      logger&.send(level, message)
+    end
+
+    private
+
+    def retry_network_exceptions(options = {})
+      initial_retries = options[:max_retries] || DEFAULT_RETRIES
+      retries = initial_retries
+      request_start = nil
+
+      begin
+        request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        log_with_retry_details(options[:logger], initial_retries - retries + 1, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, 'success', options[:tag])
+        result
+      rescue ActiveMerchant::RetriableConnectionError => e
+        retries -= 1
+
+        log_with_retry_details(options[:logger], initial_retries - retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
+        retry unless retries.zero?
+        raise ActiveMerchant::ConnectionError.new(e.message, e)
+      rescue ActiveMerchant::ConnectionError, ActiveMerchant::InvalidResponseError => e
+        retries -= 1
+        log_with_retry_details(options[:logger], initial_retries - retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
+        retry if (options[:retry_safe] || retry_safe) && !retries.zero?
+        raise
+      end
+    end
+
+    def log_with_retry_details(logger, attempts, time, message, tag)
+      NetworkConnectionRetries.log(logger, :info, 'connection_attempt=%d connection_request_time=%.4fs connection_msg="%s"' % [attempts, time, message], tag)
+    end
+
+    def derived_error_message(errors, klass)
+      key = (errors.keys & klass.ancestors).first
+      key ? errors[key] : nil
+    end
+  end
+end

data/lib/active_merchant/post_data.rb

@@ -0,0 +1,26 @@
+require 'cgi'
+
+module ActiveMerchant
+  class PostData < Hash
+    class_attribute :required_fields, instance_writer: false
+    self.required_fields = []
+
+    def []=(key, value)
+      return if value.blank? && !required?(key)
+
+      super
+    end
+
+    def to_post_data
+      collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+    end
+
+    alias to_s to_post_data
+
+    private
+
+    def required?(key)
+      required_fields.include?(key)
+    end
+  end
+end

data/lib/active_merchant/posts_data.rb

@@ -0,0 +1,92 @@
+module ActiveMerchant #:nodoc:
+  module PostsData #:nodoc:
+    def self.included(base)
+      base.class_attribute :ssl_strict
+      base.ssl_strict = true
+
+      base.class_attribute :ssl_version
+      base.ssl_version = nil
+
+      base.class_attribute :min_version
+      base.min_version = Connection::MIN_VERSION
+
+      base.class_attribute :max_version
+      base.max_version = nil
+
+      base.class_attribute :retry_safe
+      base.retry_safe = false
+
+      base.class_attribute :open_timeout
+      base.open_timeout = Connection::OPEN_TIMEOUT
+
+      base.class_attribute :read_timeout
+      base.read_timeout = Connection::READ_TIMEOUT
+
+      base.class_attribute :max_retries
+      base.max_retries = Connection::MAX_RETRIES
+
+      base.class_attribute :logger
+      base.class_attribute :wiredump_device
+
+      base.class_attribute :proxy_address
+      base.class_attribute :proxy_port
+    end
+
+    def ssl_get(endpoint, headers = {})
+      ssl_request(:get, endpoint, nil, headers)
+    end
+
+    def ssl_post(endpoint, data, headers = {})
+      ssl_request(:post, endpoint, data, headers)
+    end
+
+    def ssl_request(method, endpoint, data, headers)
+      handle_response(raw_ssl_request(method, endpoint, data, headers))
+    end
+
+    def raw_ssl_request(method, endpoint, data, headers = {})
+      logger&.warn "#{self.class} using ssl_strict=false, which is insecure" unless ssl_strict
+      logger&.warn "#{self.class} posting to plaintext endpoint, which is insecure" unless endpoint.to_s =~ /^https:/
+
+      connection = new_connection(endpoint)
+      connection.open_timeout = open_timeout
+      connection.read_timeout = read_timeout
+      connection.retry_safe   = retry_safe
+      connection.verify_peer  = ssl_strict
+      connection.ssl_version  = ssl_version
+      connection.logger       = logger
+      connection.max_retries  = max_retries
+      connection.tag          = self.class.name
+      connection.wiredump_device = wiredump_device
+      if connection.respond_to?(:min_version=)
+        connection.min_version = min_version
+        connection.max_version = max_version
+      end
+
+      connection.pem          = @options[:pem] if @options
+      connection.pem_password = @options[:pem_password] if @options
+
+      connection.ignore_http_status = @options[:ignore_http_status] if @options
+
+      connection.proxy_address = proxy_address
+      connection.proxy_port    = proxy_port
+
+      connection.request(method, data, headers)
+    end
+
+    private
+
+    def new_connection(endpoint)
+      Connection.new(endpoint)
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200...300
+        response.body
+      else
+        raise ResponseError.new(response)
+      end
+    end
+  end
+end

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = "1.45.0"
+  VERSION = '1.126.0'
 end

data/lib/active_merchant.rb

@@ -27,82 +27,37 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/conversions'
 require 'active_support/core_ext/object/conversions'
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/enumerable.rb'
-
-if(!defined?(ActiveSupport::VERSION) || (ActiveSupport::VERSION::STRING < "4.1"))
-  require 'active_support/core_ext/class/attribute_accessors'
-end
-
-require 'active_support/core_ext/class/delegating_attributes'
+require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/module/attribute_accessors'
 
-begin
-  require 'active_support/base64'
-
-  unless defined?(Base64)
-    Base64 = ActiveSupport::Base64
-  end
-
-  unless Base64.respond_to?(:strict_encode64)
-    def Base64.strict_encode64(v)
-      ActiveSupport::Base64.encode64s(v)
-    end
-  end
-rescue LoadError
-  require 'base64'
-end
-
+require 'base64'
 require 'securerandom'
 require 'builder'
 require 'cgi'
 require 'rexml/document'
 require 'timeout'
 require 'socket'
+require 'openssl'
 
-require 'active_utils/common/network_connection_retries'
-silence_warnings{require 'active_utils/common/connection'}
-require 'active_utils/common/post_data'
-require 'active_utils/common/posts_data'
+require 'active_merchant/network_connection_retries'
+require 'active_merchant/net_http_ssl_connection'
+require 'active_merchant/connection'
+require 'active_merchant/post_data'
+require 'active_merchant/posts_data'
 
 require 'active_merchant/billing'
 require 'active_merchant/version'
 require 'active_merchant/country'
 
-I18n.enforce_available_locales = false
-
-module ActiveMerchant #:nodoc:
-  OFFSITE_PAYMENT_EXTRACTION_MESSAGE = "Integrations have been extracted into a separate gem (https://github.com/Shopify/offsite_payments) and will no longer be loaded by ActiveMerchant 2.x."
-
-  module Billing #:nodoc:
-    def self.const_missing(name)
-      if name.to_s == "Integrations"
-        ActiveMerchant.deprecated(OFFSITE_PAYMENT_EXTRACTION_MESSAGE)
-        require "active_merchant/offsite_payments_shim"
-        ActiveMerchant::OffsitePaymentsShim
-      else
-        super
-      end
-    end
-
-    def self.included(klass)
-      def klass.const_missing(name)
-        if name.to_s == "Integrations"
-          ActiveMerchant.deprecated(OFFSITE_PAYMENT_EXTRACTION_MESSAGE)
-          require "active_merchant/offsite_payments_shim"
-          ActiveMerchant::OffsitePaymentsShim
-        else
-          super
-        end
-      end
-    end
-  end
-
-  def self.deprecated(message, caller=Kernel.caller[1])
-    warning = caller + ": " + message
-    if(respond_to?(:logger) && logger.present?)
+module ActiveMerchant
+  def self.deprecated(message, caller = Kernel.caller[1])
+    warning = caller + ': ' + message
+    if respond_to?(:logger) && logger.present?
       logger.warn(warning)
     else
       warn(warning)
     end
   end
 end
+
+I18n.enforce_available_locales = false

data/lib/activemerchant.rb

@@ -1 +1 @@
-require 'active_merchant'
+require 'active_merchant'