stripe 1.58.0 → 2.0.0

data/lib/stripe/account.rb

@@ -37,8 +37,8 @@ module Stripe
 
     def reject(params={}, opts={})
       opts = Util.normalize_opts(opts)
-      response, opts = request(:post, resource_url + '/reject', params, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, resource_url + '/reject', params, opts)
+      initialize_from(resp.data, opts)
     end
 
     # Somewhat unfortunately, we attempt to do a special encoding trick when
@@ -93,9 +93,9 @@ module Stripe
 
     def deauthorize(client_id, opts={})
       opts = {:api_base => Stripe.connect_base}.merge(Util.normalize_opts(opts))
-      response, opts = request(:post, '/oauth/deauthorize', { 'client_id' => client_id, 'stripe_user_id' => self.id }, opts)
+      resp, opts = request(:post, '/oauth/deauthorize', { 'client_id' => client_id, 'stripe_user_id' => self.id }, opts)
       opts.delete(:api_base) # the api_base here is a one-off, don't persist it
-      Util.convert_to_stripe_object(response, opts)
+      Util.convert_to_stripe_object(resp.data, opts)
     end
 
     ARGUMENT_NOT_PROVIDED = Object.new

data/lib/stripe/api_operations/create.rb

@@ -2,8 +2,8 @@ module Stripe
   module APIOperations
     module Create
       def create(params={}, opts={})
-        response, opts = request(:post, resource_url, params, opts)
-        Util.convert_to_stripe_object(response, opts)
+        resp, opts = request(:post, resource_url, params, opts)
+        Util.convert_to_stripe_object(resp.data, opts)
       end
     end
   end

data/lib/stripe/api_operations/delete.rb

@@ -3,8 +3,8 @@ module Stripe
     module Delete
       def delete(params={}, opts={})
         opts = Util.normalize_opts(opts)
-        response, opts = request(:delete, resource_url, params, opts)
-        initialize_from(response, opts)
+        resp, opts = request(:delete, resource_url, params, opts)
+        initialize_from(resp.data, opts)
       end
     end
   end

data/lib/stripe/api_operations/list.rb

@@ -4,8 +4,8 @@ module Stripe
       def list(filters={}, opts={})
         opts = Util.normalize_opts(opts)
 
-        response, opts = request(:get, resource_url, filters, opts)
-        obj = ListObject.construct_from(response, opts)
+        resp, opts = request(:get, resource_url, filters, opts)
+        obj = ListObject.construct_from(resp.data, opts)
 
         # set filters so that we can fetch the same limit, expansions, and
         # predicates when accessing the next and previous pages

data/lib/stripe/api_operations/request.rb

@@ -2,17 +2,23 @@ module Stripe
   module APIOperations
     module Request
       module ClassMethods
-        OPTS_KEYS_TO_PERSIST = Set[:api_key, :api_base, :stripe_account, :stripe_version]
+        OPTS_KEYS_TO_PERSIST = Set[:api_key, :api_base, :client, :stripe_account, :stripe_version]
 
         def request(method, url, params={}, opts={})
           opts = Util.normalize_opts(opts)
+          opts[:client] ||= StripeClient.active_client
 
           headers = opts.clone
           api_key = headers.delete(:api_key)
           api_base = headers.delete(:api_base)
+          client = headers.delete(:client)
           # Assume all remaining opts must be headers
 
-          response, opts[:api_key] = Stripe.request(method, url, api_key, params, headers, api_base)
+          resp, opts[:api_key] = client.execute_request(
+            method, url,
+            api_base: api_base, api_key: api_key,
+            headers: headers, params: params
+          )
 
           # Hash#select returns an array before 1.9
           opts_to_persist = {}
@@ -22,7 +28,7 @@ module Stripe
             end
           end
 
-          [response, opts_to_persist]
+          [resp, opts_to_persist]
         end
       end
 

data/lib/stripe/api_operations/save.rb

@@ -21,8 +21,8 @@ module Stripe
             end
           end
 
-          response, opts = request(:post, "#{resource_url}/#{id}", params, opts)
-          Util.convert_to_stripe_object(response, opts)
+          resp, opts = request(:post, "#{resource_url}/#{id}", params, opts)
+          Util.convert_to_stripe_object(resp.data, opts)
         end
       end
 
@@ -57,10 +57,8 @@ module Stripe
         # generated a uri for this object with an identifier baked in
         values.delete(:id)
 
-        response, opts = request(:post, save_url, values, opts)
-        initialize_from(response, opts)
-
-        self
+        resp, opts = request(:post, save_url, values, opts)
+        initialize_from(resp.data, opts)
       end
 
       def self.included(base)

data/lib/stripe/api_resource.rb

@@ -54,8 +54,8 @@ module Stripe
     end
 
     def refresh
-      response, opts = request(:get, resource_url, @retrieve_params)
-      initialize_from(response, opts)
+      resp, opts = request(:get, resource_url, @retrieve_params)
+      initialize_from(resp.data, opts)
     end
 
     def self.retrieve(id, opts={})

data/lib/stripe/bank_account.rb

@@ -5,8 +5,8 @@ module Stripe
     extend Stripe::APIOperations::List
 
     def verify(params={}, opts={})
-      response, opts = request(:post, resource_url + '/verify', params, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, resource_url + '/verify', params, opts)
+      initialize_from(resp.data, opts)
     end
 
     def resource_url

data/lib/stripe/bitcoin_receiver.rb

@@ -10,7 +10,7 @@ module Stripe
     end
 
     def resource_url
-      if respond_to?(:customer) && !self.customer.nil?
+      if respond_to?(:customer) && !self.customer.nil? && self.customer != ""
         "#{Customer.resource_url}/#{CGI.escape(customer)}/sources/#{CGI.escape(id)}"
       else
         "#{self.class.resource_url}/#{CGI.escape(id)}"

data/lib/stripe/charge.rb

@@ -20,41 +20,41 @@ module Stripe
         # from the server
         self.refresh
       else
-        response, opts = request(:post, refund_url, params, opts)
-        initialize_from(response, opts)
+        resp, opts = request(:post, refund_url, params, opts)
+        initialize_from(resp.data, opts)
       end
     end
 
     def capture(params={}, opts={})
-      response, opts = request(:post, capture_url, params, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, capture_url, params, opts)
+      initialize_from(resp.data, opts)
     end
 
     def update_dispute(params={}, opts={})
-      response, opts = request(:post, dispute_url, params, opts)
-      initialize_from({ :dispute => response }, opts, true)
+      resp, opts = request(:post, dispute_url, params, opts)
+      initialize_from({ :dispute => resp.data }, opts, true)
       dispute
     end
 
     def close_dispute(params={}, opts={})
-      response, opts = request(:post, close_dispute_url, params, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, close_dispute_url, params, opts)
+      initialize_from(resp.data, opts)
     end
 
     def mark_as_fraudulent
       params = {
         :fraud_details => { :user_report => 'fraudulent' }
       }
-      response, opts = request(:post, resource_url, params)
-      initialize_from(response, opts)
+      resp, opts = request(:post, resource_url, params)
+      initialize_from(resp.data, opts)
     end
 
     def mark_as_safe
       params = {
         :fraud_details => { :user_report => 'safe' }
       }
-      response, opts = request(:post, resource_url, params)
-      initialize_from(response, opts)
+      resp, opts = request(:post, resource_url, params)
+      initialize_from(resp.data, opts)
     end
 
     private

data/lib/stripe/customer.rb

@@ -38,20 +38,20 @@ module Stripe
     end
 
     def cancel_subscription(params={}, opts={})
-      response, opts = request(:delete, subscription_url, params, opts)
-      initialize_from({ :subscription => response }, opts, true)
+      resp, opts = request(:delete, subscription_url, params, opts)
+      initialize_from({ :subscription => resp.data }, opts, true)
       subscription
     end
 
     def update_subscription(params={}, opts={})
-      response, opts = request(:post, subscription_url, params, opts)
-      initialize_from({ :subscription => response }, opts, true)
+      resp, opts = request(:post, subscription_url, params, opts)
+      initialize_from({ :subscription => resp.data }, opts, true)
       subscription
     end
 
     def create_subscription(params={}, opts={})
-      response, opts = request(:post, subscriptions_url, params, opts)
-      initialize_from({ :subscription => response }, opts, true)
+      resp, opts = request(:post, subscriptions_url, params, opts)
+      initialize_from({ :subscription => resp.data }, opts, true)
       subscription
     end
 

data/lib/stripe/dispute.rb

@@ -1,12 +1,11 @@
 module Stripe
   class Dispute < APIResource
     extend Stripe::APIOperations::List
-    extend Stripe::APIOperations::Create
     include Stripe::APIOperations::Save
 
     def close(params={}, opts={})
-      response, opts = request(:post, close_url, params, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, close_url, params, opts)
+      initialize_from(resp.data, opts)
     end
 
     def close_url

data/lib/stripe/errors.rb

@@ -3,14 +3,22 @@ module Stripe
   # errors derive.
   class StripeError < StandardError
     attr_reader :message
-    attr_reader :http_status
+
+    # Response contains a StripeResponse object that has some basic information
+    # about the response that conveyed the error.
+    attr_accessor :response
+
+    # These fields are now available as part of #response and that usage should
+    # be preferred.
     attr_reader :http_body
     attr_reader :http_headers
+    attr_reader :http_status
+    attr_reader :json_body # equivalent to #data
     attr_reader :request_id
-    attr_reader :json_body
 
-    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil,
-                   http_headers=nil)
+    # Initializes a StripeError.
+    def initialize(message=nil, http_status: nil, http_body: nil, json_body: nil,
+                   http_headers: nil)
       @message = message
       @http_status = http_status
       @http_body = http_body
@@ -49,9 +57,10 @@ module Stripe
   class CardError < StripeError
     attr_reader :param, :code
 
-    def initialize(message, param, code, http_status=nil, http_body=nil, json_body=nil,
-                   http_headers=nil)
-      super(message, http_status, http_body, json_body, http_headers)
+    def initialize(message, param, code, http_status: nil, http_body: nil, json_body: nil,
+                   http_headers: nil)
+      super(message, http_status: http_status, http_body: http_body,
+        json_body: json_body, http_headers: http_headers)
       @param = param
       @code = code
     end
@@ -62,9 +71,10 @@ module Stripe
   class InvalidRequestError < StripeError
     attr_accessor :param
 
-    def initialize(message, param, http_status=nil, http_body=nil, json_body=nil,
-                   http_headers=nil)
-      super(message, http_status, http_body, json_body, http_headers)
+    def initialize(message, param, http_status: nil, http_body: nil, json_body: nil,
+                   http_headers: nil)
+      super(message, http_status: http_status, http_body: http_body,
+        json_body: json_body, http_headers: http_headers)
       @param = param
     end
   end

data/lib/stripe/invoice.rb

@@ -5,13 +5,13 @@ module Stripe
     extend Stripe::APIOperations::Create
 
     def self.upcoming(params, opts={})
-      response, opts = request(:get, upcoming_url, params, opts)
-      Util.convert_to_stripe_object(response, opts)
+      resp, opts = request(:get, upcoming_url, params, opts)
+      Util.convert_to_stripe_object(resp.data, opts)
     end
 
     def pay(opts={})
-      response, opts = request(:post, pay_url, {}, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, pay_url, {}, opts)
+      initialize_from(resp.data, opts)
     end
 
     private

data/lib/stripe/list_object.rb

@@ -64,8 +64,8 @@ module Stripe
 
     def retrieve(id, opts={})
       id, retrieve_params = Util.normalize_id(id)
-      response, opts = request(:get,"#{resource_url}/#{CGI.escape(id)}", retrieve_params, opts)
-      Util.convert_to_stripe_object(response, opts)
+      resp, opts = request(:get,"#{resource_url}/#{CGI.escape(id)}", retrieve_params, opts)
+      Util.convert_to_stripe_object(resp.data, opts)
     end
 
     # Fetches the next page in the resource list (if there is one).

data/lib/stripe/order.rb

@@ -5,13 +5,13 @@ module Stripe
     include Stripe::APIOperations::Save
 
     def pay(params, opts={})
-      response, opts = request(:post, pay_url, params, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, pay_url, params, opts)
+      initialize_from(resp.data, opts)
     end
 
     def return_order(params, opts={})
-      response, opts = request(:post, returns_url, params, opts)
-      Util.convert_to_stripe_object(response, opts)
+      resp, opts = request(:post, returns_url, params, opts)
+      Util.convert_to_stripe_object(resp.data, opts)
     end
 
     private

data/lib/stripe/reversal.rb

@@ -1,7 +1,7 @@
 module Stripe
   class Reversal < APIResource
-    include Stripe::APIOperations::Save
     extend Stripe::APIOperations::List
+    include Stripe::APIOperations::Save
 
     def resource_url
       "#{Transfer.resource_url}/#{CGI.escape(transfer)}/reversals/#{CGI.escape(id)}"

data/lib/stripe/source.rb

@@ -4,8 +4,8 @@ module Stripe
     include Stripe::APIOperations::Save
 
     def verify(params={}, opts={})
-      response, opts = request(:post, resource_url + '/verify', params, opts)
-      initialize_from(response, opts)
+      resp, opts = request(:post, resource_url + '/verify', params, opts)
+      initialize_from(resp.data, opts)
     end
   end
 end

data/lib/stripe/stripe_client.rb

@@ -0,0 +1,396 @@
+module Stripe
+  # StripeClient executes requests against the Stripe API and allows a user to
+  # recover both a resource a call returns as well as a response object that
+  # contains information on the HTTP call.
+  class StripeClient
+    attr_accessor :conn
+
+    # Initializes a new StripeClient. Expects a Faraday connection object, and
+    # uses a default connection unless one is passed.
+    def initialize(conn = nil)
+      self.conn = conn || self.class.default_conn
+      @system_profiler = SystemProfiler.new
+    end
+
+    def self.active_client
+      Thread.current[:stripe_client] || default_client
+    end
+
+    def self.default_client
+      @default_client ||= StripeClient.new(default_conn)
+    end
+
+    # A default Faraday connection to be used when one isn't configured. This
+    # object should never be mutated, and instead instantiating your own
+    # connection and wrapping it in a StripeClient object should be preferred.
+    def self.default_conn
+      # We're going to keep connections around so that we can take advantage
+      # of connection re-use, so make sure that we have a separate connection
+      # object per thread.
+      Thread.current[:stripe_client_default_conn] ||= begin
+        conn = Faraday.new do |c|
+          c.use Faraday::Request::UrlEncoded
+          c.use Faraday::Response::RaiseError
+          c.adapter Faraday.default_adapter
+        end
+
+        if Stripe.verify_ssl_certs
+          conn.ssl.verify = true
+          conn.ssl.cert_store = Stripe.ca_store
+        else
+          conn.ssl.verify = false
+
+          unless @verify_ssl_warned
+            @verify_ssl_warned = true
+            $stderr.puts("WARNING: Running without SSL cert verification. " \
+              "You should never do this in production. " \
+              "Execute 'Stripe.verify_ssl_certs = true' to enable verification.")
+          end
+        end
+
+        conn
+      end
+    end
+
+    # Checks if an error is a problem that we should retry on. This includes both
+    # socket errors that may represent an intermittent problem and some special
+    # HTTP statuses.
+    def self.should_retry?(e, retry_count)
+      return false if retry_count >= Stripe.max_network_retries
+
+      # Retry on timeout-related problems (either on open or read).
+      return true if e.is_a?(Faraday::TimeoutError)
+
+      # Destination refused the connection, the connection was reset, or a
+      # variety of other connection failures. This could occur from a single
+      # saturated server, so retry in case it's intermittent.
+      return true if e.is_a?(Faraday::ConnectionFailed)
+
+      if e.is_a?(Faraday::ClientError) && e.response
+        # 409 conflict
+        return true if e.response[:status] == 409
+      end
+
+      false
+    end
+
+    def self.sleep_time(retry_count)
+      # Apply exponential backoff with initial_network_retry_delay on the
+      # number of attempts so far as inputs. Do not allow the number to exceed
+      # max_network_retry_delay.
+      sleep_seconds = [Stripe.initial_network_retry_delay * (2 ** (retry_count - 1)), Stripe.max_network_retry_delay].min
+
+      # Apply some jitter by randomizing the value in the range of (sleep_seconds
+      # / 2) to (sleep_seconds).
+      sleep_seconds = sleep_seconds * (0.5 * (1 + rand()))
+
+      # But never sleep less than the base sleep seconds.
+      sleep_seconds = [Stripe.initial_network_retry_delay, sleep_seconds].max
+
+      sleep_seconds
+    end
+
+    # Executes the API call within the given block. Usage looks like:
+    #
+    #     client = StripeClient.new
+    #     charge, resp = client.request { Charge.create }
+    #
+    def request(&block)
+      @last_response = nil
+      old_stripe_client = Thread.current[:stripe_client]
+      Thread.current[:stripe_client] = self
+
+      begin
+        res = block.call
+        [res, @last_response]
+      ensure
+        Thread.current[:stripe_client] = old_stripe_client
+      end
+    end
+
+    def execute_request(method, url,
+        api_base: nil, api_key: nil, headers: {}, params: {})
+
+      api_base ||= Stripe.api_base
+      api_key ||= Stripe.api_key
+
+      check_api_key!(api_key)
+
+      params = Util.objects_to_ids(params)
+      url = api_url(url, api_base)
+
+      case method.to_s.downcase.to_sym
+      when :get, :head, :delete
+        # Make params into GET parameters
+        url += "#{URI.parse(url).query ? '&' : '?'}#{Util.encode_parameters(params)}" if params && params.any?
+        payload = nil
+      else
+        if headers[:content_type] && headers[:content_type] == "multipart/form-data"
+          payload = params
+        else
+          payload = Util.encode_parameters(params)
+        end
+      end
+
+      http_resp = execute_request_with_rescues(api_base, 0) do
+        conn.run_request(
+          method,
+          url,
+          payload,
+          # TODO: Convert RestClient-style parameters.
+          request_headers(api_key, method).update(headers)
+        ) do |req|
+          req.options.open_timeout = Stripe.open_timeout
+          req.options.timeout = Stripe.read_timeout
+        end
+      end
+
+      begin
+        resp = StripeResponse.from_faraday_response(http_resp)
+      rescue JSON::ParserError
+        raise general_api_error(http_resp.code, http_resp.body)
+      end
+
+      # Allows StripeClient#request to return a response object to a caller.
+      @last_response = resp
+      [resp, api_key]
+    end
+
+    private
+
+    def api_url(url='', api_base=nil)
+      (api_base || Stripe.api_base) + url
+    end
+
+    def check_api_key!(api_key)
+      unless api_key
+        raise AuthenticationError.new('No API key provided. ' \
+          'Set your API key using "Stripe.api_key = <API-KEY>". ' \
+          'You can generate API keys from the Stripe web interface. ' \
+          'See https://stripe.com/api for details, or email support@stripe.com ' \
+          'if you have any questions.')
+      end
+
+      if api_key =~ /\s/
+        raise AuthenticationError.new('Your API key is invalid, as it contains ' \
+          'whitespace. (HINT: You can double-check your API key from the ' \
+          'Stripe web interface. See https://stripe.com/api for details, or ' \
+          'email support@stripe.com if you have any questions.)')
+      end
+    end
+
+    def execute_request_with_rescues(api_base, retry_count, &block)
+      begin
+        resp = block.call
+
+      # We rescue all exceptions from a request so that we have an easy spot to
+      # implement our retry logic across the board. We'll re-raise if it's a type
+      # of exception that we didn't expect to handle.
+      rescue => e
+        if self.class.should_retry?(e, retry_count)
+          retry_count = retry_count + 1
+          sleep self.class.sleep_time(retry_count)
+          retry
+        end
+
+        case e
+        when Faraday::ClientError
+          if e.response
+            handle_api_error(e.response)
+          else
+            handle_network_error(e, retry_count, api_base)
+          end
+
+        # Only handle errors when we know we can do so, and re-raise otherwise.
+        # This should be pretty infrequent.
+        else
+          raise
+        end
+      end
+
+      resp
+    end
+
+    def general_api_error(status, body)
+      APIError.new("Invalid response object from API: #{body.inspect} " +
+                   "(HTTP response code was #{status})",
+                   http_status: status, http_body: body)
+    end
+
+
+    def handle_api_error(http_resp)
+      begin
+        resp = StripeResponse.from_faraday_hash(http_resp)
+        error = resp.data[:error]
+
+        unless error && error.is_a?(Hash)
+          raise StripeError.new("Indeterminate error")
+        end
+
+      rescue JSON::ParserError, StripeError
+        raise general_api_error(http_resp[:status], http_resp[:body])
+      end
+
+      case resp.http_status
+      when 400, 404
+        error = InvalidRequestError.new(
+          error[:message], error[:param],
+          http_status: resp.http_status, http_body: resp.http_body,
+          json_body: resp.data, http_headers: resp.http_headers
+        )
+      when 401
+        error = AuthenticationError.new(
+          error[:message],
+          http_status: resp.http_status, http_body: resp.http_body,
+          json_body: resp.data, http_headers: resp.http_headers
+        )
+      when 402
+        error = CardError.new(
+          error[:message], error[:param], error[:code],
+          http_status: resp.http_status, http_body: resp.http_body,
+          json_body: resp.data, http_headers: resp.http_headers
+        )
+      when 403
+        error = PermissionError.new(
+          error[:message],
+          http_status: resp.http_status, http_body: resp.http_body,
+          json_body: resp.data, http_headers: resp.http_headers
+        )
+      when 429
+        error = RateLimitError.new(
+          error[:message],
+          http_status: resp.http_status, http_body: resp.http_body,
+          json_body: resp.data, http_headers: resp.http_headers
+        )
+      else
+        error = APIError.new(
+          error[:message],
+          http_status: resp.http_status, http_body: resp.http_body,
+          json_body: resp.data, http_headers: resp.http_headers
+        )
+      end
+
+      error.response = resp
+      raise(error)
+    end
+
+    def handle_network_error(e, retry_count, api_base=nil)
+      case e
+      when Faraday::ConnectionFailed
+        message = "Unexpected error communicating when trying to connect to Stripe. " \
+          "You may be seeing this message because your DNS is not working. " \
+          "To check, try running 'host stripe.com' from the command line."
+
+      when Faraday::SSLError
+        message = "Could not establish a secure connection to Stripe, you may " \
+                  "need to upgrade your OpenSSL version. To check, try running " \
+                  "'openssl s_client -connect api.stripe.com:443' from the " \
+                  "command line."
+
+      when Faraday::TimeoutError
+        api_base = Stripe.api_base unless api_base
+        message = "Could not connect to Stripe (#{api_base}). " \
+          "Please check your internet connection and try again. " \
+          "If this problem persists, you should check Stripe's service status at " \
+          "https://twitter.com/stripestatus, or let us know at support@stripe.com."
+
+      else
+        message = "Unexpected error communicating with Stripe. " \
+          "If this problem persists, let us know at support@stripe.com."
+
+      end
+
+      if retry_count > 0
+        message += " Request was retried #{retry_count} times."
+      end
+
+      raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+    end
+
+    def request_headers(api_key, method)
+      headers = {
+        'User-Agent' => "Stripe/v1 RubyBindings/#{Stripe::VERSION}",
+        'Authorization' => "Bearer #{api_key}",
+        'Content-Type' => 'application/x-www-form-urlencoded'
+      }
+
+      # It is only safe to retry network failures on post and delete
+      # requests if we add an Idempotency-Key header
+      if [:post, :delete].include?(method) && Stripe.max_network_retries > 0
+        headers['Idempotency-Key'] ||= SecureRandom.uuid
+      end
+
+      headers['Stripe-Version'] = Stripe.api_version if Stripe.api_version
+      headers['Stripe-Account'] = Stripe.stripe_account if Stripe.stripe_account
+
+      user_agent = @system_profiler.user_agent
+      begin
+        headers.update(
+          'X-Stripe-Client-User-Agent' => JSON.generate(user_agent)
+        )
+      rescue => e
+        headers.update(
+          'X-Stripe-Client-Raw-User-Agent' => user_agent.inspect,
+          :error => "#{e} (#{e.class})"
+        )
+      end
+
+      headers
+    end
+
+    # SystemProfiler extracts information about the system that we're running
+    # in so that we can generate a rich user agent header to help debug
+    # integrations.
+    class SystemProfiler
+      def self.get_uname
+        if File.exist?('/proc/version')
+          File.read('/proc/version').strip
+        else
+          case RbConfig::CONFIG['host_os']
+          when /linux|darwin|bsd|sunos|solaris|cygwin/i
+            get_uname_from_system
+          when /mswin|mingw/i
+            get_uname_from_system_ver
+          else
+            "unknown platform"
+          end
+        end
+      end
+
+      def self.get_uname_from_system
+        (`uname -a 2>/dev/null` || '').strip
+      rescue Errno::ENOENT
+        "uname executable not found"
+      rescue Errno::ENOMEM # couldn't create subprocess
+        "uname lookup failed"
+      end
+
+      def self.get_uname_from_system_ver
+        (`ver` || '').strip
+      rescue Errno::ENOENT
+        "ver executable not found"
+      rescue Errno::ENOMEM # couldn't create subprocess
+        "uname lookup failed"
+      end
+
+      def initialize
+        @uname = self.class.get_uname
+      end
+
+      def user_agent
+        lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+        {
+          :bindings_version => Stripe::VERSION,
+          :lang => 'ruby',
+          :lang_version => lang_version,
+          :platform => RUBY_PLATFORM,
+          :engine => defined?(RUBY_ENGINE) ? RUBY_ENGINE : '',
+          :publisher => 'stripe',
+          :uname => @uname,
+          :hostname => Socket.gethostname,
+        }
+      end
+    end
+  end
+end