zendesk_api 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 138f1dab58b3b37d450c4b1dd9200b1c878944b19571f53888b2c4d17a307276
-  data.tar.gz: 24459eda2e613e21be9924ad6bb571e53861f949d6be291f2bec3516cd1e9ad2
+  metadata.gz: 4804fd37b3a0cca8014505335c2f5ab6177a678a1dd429b56cb012804f65ea31
+  data.tar.gz: d7db1542be1bf6913dfe2340c3d6a1b4742386e9571f91a249a5e1edb44e8edc
 SHA512:
-  metadata.gz: 55f26e4b66e457d5e9e634eefa44fc8b50da170ab2d5a5f97d2460daa423da04d7c607bfa626b1ecd7ce56117a1ee410e7213df6717d84a8e4a109392e1611a5
-  data.tar.gz: 0bab4d20e8989a0e1a4f8be708f76ccd462fddec1b880fb360591f9f048d74c5bbd17d20b678290fb6891dcb0fa6755139e5165fb7c7ea28055643abe583efbb
+  metadata.gz: 10372ee1b741eab42e07127dd81c355d5b2e3707627b2e6d8aa86f9cd01c2c100860d1467935b37d202ee3bd9df98bef8379b6312c770fc736180bc96e25d085
+  data.tar.gz: 4190bc1b3a8e798302df52f5544da095e3f758783b6a9ebf0191ef2fe44a019939746a29b9200208bf1664aee57816a30cd93d1e2b11903bec2112146e4a1415

data/lib/zendesk_api/actions.rb

@@ -43,8 +43,8 @@ module ZendeskAPI
     end
 
     # Saves, returning false if it fails and attaching the errors
-    def save(options = {}, &block)
-      save!(options, &block)
+    def save(options = {}, &)
+      save!(options, &)
     rescue ZendeskAPI::Error::RecordInvalid => e
       @errors = e.errors
       false
@@ -66,7 +66,7 @@ module ZendeskAPI
       self.class.associations.each do |association_data|
         association_name = association_data[:name]
 
-        next unless send("#{association_name}_used?") && association = send(association_name)
+        next unless send("#{association_name}_used?") && (association = send(association_name))
 
         inline_creation = association_data[:inline] == :create && new_record?
         changed = association.is_a?(Collection) || association.changed?
@@ -110,7 +110,7 @@ module ZendeskAPI
         @client = client # so we can use client.logger in rescue
 
         raise ArgumentError, "No :id given" unless options[:id] || options["id"] || ancestors.include?(SingularResource)
-        association = options.delete(:association) || Association.new(:class => self)
+        association = options.delete(:association) || Association.new(class: self)
 
         includes = Array(options[:include])
         options[:include] = includes.join(",") if includes.any?
@@ -127,8 +127,8 @@ module ZendeskAPI
       # Finds, returning nil if it fails
       # @param [Client] client The {Client} object to be used
       # @param [Hash] options Any additional GET parameters to be added
-      def find(client, options = {}, &block)
-        find!(client, options, &block)
+      def find(client, options = {}, &)
+        find!(client, options, &)
       rescue ZendeskAPI::Error::ClientError
         nil
       end
@@ -157,8 +157,8 @@ module ZendeskAPI
       # Creates, returning nil if it fails
       # @param [Client] client The {Client} object to be used
       # @param [Hash] options Any additional GET parameters to be added
-      def create(client, attributes = {}, &block)
-        create!(client, attributes, &block)
+      def create(client, attributes = {}, &)
+        create!(client, attributes, &)
       rescue ZendeskAPI::Error::ClientError
         nil
       end
@@ -170,9 +170,9 @@ module ZendeskAPI
     # @param [Client] client The {Client} object to be used
     # @param [Array] attributes_array An array of resources to be created.
     # @return [JobStatus] the {JobStatus} instance for this create job
-    def create_many!(client, attributes_array, association = Association.new(:class => self))
+    def create_many!(client, attributes_array, association = Association.new(class: self))
       response = client.connection.post("#{association.generate_path}/create_many") do |req|
-        req.body = { resource_name => attributes_array }
+        req.body = {resource_name => attributes_array}
 
         yield req if block_given?
       end
@@ -185,9 +185,9 @@ module ZendeskAPI
     # Creates or updates resource using the create_or_update endpoint.
     # @param [Client] client The {Client} object to be used
     # @param [Hash] attributes The attributes to create.
-    def create_or_update!(client, attributes, association = Association.new(:class => self))
+    def create_or_update!(client, attributes, association = Association.new(class: self))
       response = client.connection.post("#{association.generate_path}/create_or_update") do |req|
-        req.body = { singular_resource_name => attributes }
+        req.body = {singular_resource_name => attributes}
 
         yield req if block_given?
       end
@@ -204,10 +204,10 @@ module ZendeskAPI
     #
     # @return [JobStatus] the {JobStatus} instance for this destroy job
     def create_or_update_many!(client, attributes)
-      association = Association.new(:class => self)
+      association = Association.new(class: self)
 
       response = client.connection.post("#{association.generate_path}/create_or_update_many") do |req|
-        req.body = { resource_name => attributes }
+        req.body = {resource_name => attributes}
 
         yield req if block_given?
       end
@@ -239,8 +239,8 @@ module ZendeskAPI
     end
 
     # Destroys, returning false on error.
-    def destroy(&block)
-      destroy!(&block)
+    def destroy(&)
+      destroy!(&)
     rescue ZendeskAPI::Error::ClientError
       false
     end
@@ -249,15 +249,15 @@ module ZendeskAPI
       # Deletes a resource given the id passed in.
       # @param [Client] client The {Client} object to be used
       # @param [Hash] opts The optional parameters to pass. Defaults to {}
-      def destroy!(client, opts = {}, &block)
-        new(client, opts).destroy!(&block)
+      def destroy!(client, opts = {}, &)
+        new(client, opts).destroy!(&)
 
         true
       end
 
       # Destroys, returning false on error.
-      def destroy(client, attributes = {}, &block)
-        destroy!(client, attributes, &block)
+      def destroy(client, attributes = {}, &)
+        destroy!(client, attributes, &)
       rescue ZendeskAPI::Error::ClientError
         false
       end
@@ -269,9 +269,9 @@ module ZendeskAPI
     # @param [Client] client The {Client} object to be used
     # @param [Array] ids An array of ids to destroy
     # @return [JobStatus] the {JobStatus} instance for this destroy job
-    def destroy_many!(client, ids, association = Association.new(:class => self))
+    def destroy_many!(client, ids, association = Association.new(class: self))
       response = client.connection.delete("#{association.generate_path}/destroy_many") do |req|
-        req.params = { :ids => ids.join(',') }
+        req.params = {ids: ids.join(",")}
 
         yield req if block_given?
       end
@@ -289,8 +289,8 @@ module ZendeskAPI
 
     module ClassMethod
       # Updates, returning false on error.
-      def update(client, attributes = {}, &block)
-        update!(client, attributes, &block)
+      def update(client, attributes = {}, &)
+        update!(client, attributes, &)
       rescue ZendeskAPI::Error::ClientError
         false
       end
@@ -298,11 +298,11 @@ module ZendeskAPI
       # Updates a resource given the id passed in.
       # @param [Client] client The {Client} object to be used
       # @param [Hash] attributes The attributes to update. Default to {
-      def update!(client, attributes = {}, &block)
+      def update!(client, attributes = {}, &)
         ZendeskAPI::Client.check_deprecated_namespace_usage attributes, singular_resource_name
-        resource = new(client, :id => attributes.delete(:id), :global => attributes.delete(:global), :association => attributes.delete(:association))
+        resource = new(client, id: attributes.delete(:id), global: attributes.delete(:global), association: attributes.delete(:association))
         resource.attributes.merge!(attributes)
-        resource.save!(:force_update => resource.is_a?(SingularResource), &block)
+        resource.save!(force_update: resource.is_a?(SingularResource), &)
         resource
       end
     end
@@ -315,14 +315,14 @@ module ZendeskAPI
     # @param [Hash] attributes The attributes to update resources with
     # @return [JobStatus] the {JobStatus} instance for this destroy job
     def update_many!(client, ids_or_attributes, attributes = {})
-      association = attributes.delete(:association) || Association.new(:class => self)
+      association = attributes.delete(:association) || Association.new(class: self)
 
       response = client.connection.put("#{association.generate_path}/update_many") do |req|
         if attributes == {}
-          req.body = { resource_name => ids_or_attributes }
+          req.body = {resource_name => ids_or_attributes}
         else
-          req.params = { :ids => ids_or_attributes.join(',') }
-          req.body = { singular_resource_name => attributes }
+          req.params = {ids: ids_or_attributes.join(",")}
+          req.body = {singular_resource_name => attributes}
         end
 
         yield req if block_given?

data/lib/zendesk_api/association.rb

@@ -1,4 +1,4 @@
-require 'zendesk_api/helpers'
+require_relative "helpers"
 
 module ZendeskAPI
   # Represents an association between two resources
@@ -43,7 +43,7 @@ module ZendeskAPI
     # * with_parent - Include the parent path (false by default)
     # * with_id - Include the instance id, if possible (true)
     def generate_path(*args)
-      options = SilentMash.new(:with_id => true)
+      options = SilentMash.new(with_id: true)
       if args.last.is_a?(Hash)
         original_options = args.pop
         options.merge!(original_options)
@@ -66,7 +66,7 @@ module ZendeskAPI
         namespace[0] = @options.path || @options[:class].resource_path
       end
 
-      if id = extract_id(instance, options, original_options)
+      if (id = extract_id(instance, options, original_options))
         namespace << id
       end
 
@@ -93,7 +93,7 @@ module ZendeskAPI
 
     # @return [Array<String>] ['ZendeskAPI', 'Voice', etc.. ]
     def ignorable_namespace_strings
-      ZendeskAPI::DataNamespace.descendants.map { |klass| klass.to_s.split('::') }.flatten.uniq
+      ZendeskAPI::DataNamespace.descendants.map { |klass| klass.to_s.split("::") }.flatten.uniq
     end
 
     def _side_load(resource, side_loads)
@@ -106,10 +106,10 @@ module ZendeskAPI
       end
     end
 
-    def side_load_from_parent_id(resource, side_loads, key)
+    def side_load_from_parent_id(resource, side_loads, _key)
       key = "#{resource.class.singular_resource_name}_id"
 
-      resource.send("#{options.name}=", _side_load(resource, side_loads.select {|side_load|
+      resource.send("#{options.name}=", _side_load(resource, side_loads.select { |side_load|
         side_load[key] == resource.id
       }))
     end
@@ -117,7 +117,7 @@ module ZendeskAPI
     def side_load_from_child_ids(resource, side_loads, plural_key)
       ids = resource.send(plural_key)
 
-      resource.send("#{options.name}=", _side_load(resource, side_loads.select {|side_load|
+      resource.send("#{options.name}=", _side_load(resource, side_loads.select { |side_load|
         ids.include?(side_load[options.include_key])
       }))
     end
@@ -178,7 +178,7 @@ module ZendeskAPI
 
     def extract_id(instance, options, original_options)
       if options[:with_id] && !@options[:class].ancestors.include?(SingularResource)
-        if instance && instance.id
+        if instance&.id
           instance.id
         elsif options[:id]
           original_options.delete(:id) || original_options.delete("id")

data/lib/zendesk_api/associations.rb

@@ -1,4 +1,4 @@
-require 'zendesk_api/helpers'
+require_relative "helpers"
 
 module ZendeskAPI
   # This module holds association method for resources.
@@ -14,14 +14,14 @@ module ZendeskAPI
     end
 
     def wrap_resource(resource, class_level_association, options = {})
-      instance_association = Association.new(class_level_association.merge(:parent => self))
+      instance_association = Association.new(class_level_association.merge(parent: self))
       klass = class_level_association[:class]
 
       case resource
       when Hash
-        klass.new(@client, resource.merge(:association => instance_association))
+        klass.new(@client, resource.merge(association: instance_association))
       when String, Integer
-        klass.new(@client, (options[:include_key] || :id) => resource, :association => instance_association)
+        klass.new(@client, options[:include_key] || :id => resource, :association => instance_association)
       else
         resource.association = instance_association
         resource
@@ -40,12 +40,10 @@ module ZendeskAPI
       end
 
       def associated_with(name)
-        associations.inject([]) do |associated_with, association|
+        associations.each_with_object([]) do |association, associated_with|
           if association[:include] == name.to_s
             associated_with.push(Association.new(association))
           end
-
-          associated_with
         end
       end
 
@@ -53,14 +51,14 @@ module ZendeskAPI
 
       def build_association(klass, resource_name, options)
         {
-          :class => klass,
-          :name => resource_name,
-          :inline => options.delete(:inline),
-          :path => options.delete(:path),
-          :include => (options.delete(:include) || klass.resource_name).to_s,
-          :include_key => (options.delete(:include_key) || :id).to_s,
-          :singular => options.delete(:singular),
-          :extensions => Array(options.delete(:extend))
+          class: klass,
+          name: resource_name,
+          inline: options.delete(:inline),
+          path: options.delete(:path),
+          include: (options.delete(:include) || klass.resource_name).to_s,
+          include_key: (options.delete(:include_key) || :id).to_s,
+          singular: options.delete(:singular),
+          extensions: Array(options.delete(:extend))
         }
       end
 
@@ -75,7 +73,7 @@ module ZendeskAPI
         # @param [Symbol] resource_name_or_class The underlying resource name or a class to get it from
         # @param [Hash] class_level_options The options to pass to the method definition.
         def has(resource_name_or_class, class_level_options = {})
-          if klass = class_level_options.delete(:class)
+          if (klass = class_level_options.delete(:class))
             resource_name = resource_name_or_class
           else
             klass = resource_name_or_class
@@ -83,7 +81,8 @@ module ZendeskAPI
           end
 
           class_level_association = build_association(klass, resource_name, class_level_options)
-          class_level_association.merge!(:singular => true, :id_column => "#{resource_name}_id")
+          class_level_association[:singular] = true
+          class_level_association[:id_column] = "#{resource_name}_id"
 
           associations << class_level_association
 
@@ -105,14 +104,14 @@ module ZendeskAPI
             return cached if cached && !instance_options[:reload]
 
             # find and cache association
-            instance_association = Association.new(association.merge(:parent => self))
-            resource = if klass.respond_to?(:find) && resource_id = method_missing(association[:id_column])
-              klass.find(@client, :id => resource_id, :association => instance_association)
-            elsif found = method_missing(association[:name].to_sym)
-              wrap_resource(found, association, :include_key => association[:include_key])
+            instance_association = Association.new(association.merge(parent: self))
+            resource = if klass.respond_to?(:find) && (resource_id = method_missing(association[:id_column]))
+              klass.find(@client, id: resource_id, association: instance_association)
+            elsif (found = method_missing(association[:name].to_sym))
+              wrap_resource(found, association, include_key: association[:include_key])
             elsif klass.superclass == DataResource && !association[:inline]
-              response = @client.connection.get(instance_association.generate_path(:with_parent => true))
-              klass.new(@client, response.body[klass.singular_resource_name].merge(:association => instance_association))
+              response = @client.connection.get(instance_association.generate_path(with_parent: true))
+              klass.new(@client, response.body[klass.singular_resource_name].merge(association: instance_association))
             end
 
             send("#{association[:id_column]}=", resource.id) if resource && has_key?(association[:id_column])
@@ -134,7 +133,7 @@ module ZendeskAPI
         # @param [Symbol] resource_name_or_class The underlying resource name or class to get it from
         # @param [Hash] class_level_options The options to pass to the method definition.
         def has_many(resource_name_or_class, class_level_options = {})
-          if klass = class_level_options.delete(:class)
+          if (klass = class_level_options.delete(:class))
             resource_name = resource_name_or_class
           else
             klass = resource_name_or_class
@@ -142,7 +141,8 @@ module ZendeskAPI
           end
 
           class_level_association = build_association(klass, resource_name, class_level_options)
-          class_level_association.merge!(:singular => false, :id_column => "#{resource_name}_ids")
+          class_level_association[:singular] = false
+          class_level_association[:id_column] = "#{resource_name}_ids"
 
           associations << class_level_association
 
@@ -164,12 +164,12 @@ module ZendeskAPI
             return cached if cached && !instance_opts[:reload]
 
             # find and cache association
-            instance_association = Association.new(association.merge(:parent => self))
+            instance_association = Association.new(association.merge(parent: self))
             singular_resource_name = Inflection.singular(association[:name].to_s)
 
             resources = if (ids = method_missing("#{singular_resource_name}_ids")) && ids.any?
               ids.map do |id|
-                klass.find(@client, :id => id, :association => instance_association)
+                klass.find(@client, id: id, association: instance_association)
               end.compact
             elsif (resources = method_missing(association[:name].to_sym)) && resources.any?
               resources.map { |res| wrap_resource(res, association) }
@@ -177,7 +177,7 @@ module ZendeskAPI
               []
             end
 
-            collection = ZendeskAPI::Collection.new(@client, klass, instance_opts.merge(:association => instance_association))
+            collection = ZendeskAPI::Collection.new(@client, klass, instance_opts.merge(association: instance_association))
 
             if association[:extensions].any?
               collection.extend(*association[:extensions])
@@ -198,7 +198,7 @@ module ZendeskAPI
               wrapped = resources.map { |attr| wrap_resource(attr, association) }
               send(association[:name]).replace(wrapped)
             else
-              resources.association = Association.new(association.merge(:parent => self))
+              resources.association = Association.new(association.merge(parent: self))
               instance_variable_set("@#{association[:name]}", resources)
             end
 

data/lib/zendesk_api/client.rb

@@ -1,24 +1,26 @@
-require 'zendesk_api/version'
-require 'zendesk_api/sideloading'
-require 'zendesk_api/configuration'
-require 'zendesk_api/collection'
-require 'zendesk_api/lru_cache'
-require 'zendesk_api/silent_mash'
-require 'zendesk_api/middleware/request/etag_cache'
-require 'zendesk_api/middleware/request/retry'
-require 'zendesk_api/middleware/request/raise_rate_limited'
-require 'zendesk_api/middleware/request/upload'
-require 'zendesk_api/middleware/request/encode_json'
-require 'zendesk_api/middleware/request/url_based_access_token'
-require 'zendesk_api/middleware/response/callback'
-require 'zendesk_api/middleware/response/deflate'
-require 'zendesk_api/middleware/response/gzip'
-require 'zendesk_api/middleware/response/sanitize_response'
-require 'zendesk_api/middleware/response/parse_iso_dates'
-require 'zendesk_api/middleware/response/parse_json'
-require 'zendesk_api/middleware/response/raise_error'
-require 'zendesk_api/middleware/response/logger'
-require 'zendesk_api/delegator'
+require_relative "version"
+require_relative "sideloading"
+require_relative "configuration"
+require_relative "collection"
+require_relative "lru_cache"
+require_relative "silent_mash"
+require_relative "middleware/request/etag_cache"
+require_relative "middleware/request/retry"
+require_relative "middleware/request/raise_rate_limited"
+require_relative "middleware/request/upload"
+require_relative "middleware/request/encode_json"
+require_relative "middleware/request/api_token_impersonate"
+require_relative "middleware/request/url_based_access_token"
+require_relative "middleware/response/callback"
+require_relative "middleware/response/deflate"
+require_relative "middleware/response/gzip"
+require_relative "middleware/response/sanitize_response"
+require_relative "middleware/response/parse_iso_dates"
+require_relative "middleware/response/parse_json"
+require_relative "middleware/response/raise_error"
+require_relative "middleware/response/logger"
+require_relative "middleware/response/zendesk_request_event"
+require_relative "delegator"
 
 module ZendeskAPI
   # The top-level class that handles configuration and connection to the Zendesk API.
@@ -30,11 +32,13 @@ module ZendeskAPI
     attr_reader :config
     # @return [Array] Custom response callbacks
     attr_reader :callbacks
+    # @return [Hash] Memoized account data
+    attr_reader :account_data
 
     # Handles resources such as 'tickets'. Any options are passed to the underlying collection, except reload which disregards
     # memoization and creates a new Collection instance.
     # @return [Collection] Collection instance for resource
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args, &)
       method = method.to_s
       options = args.last.is_a?(Hash) ? args.pop : {}
       unless config.use_resource_cache
@@ -43,7 +47,7 @@ module ZendeskAPI
         return ZendeskAPI::Collection.new(self, resource_class, options)
       end
 
-      @resource_cache[method] ||= { :class => nil, :cache => ZendeskAPI::LRUCache.new }
+      @resource_cache[method] ||= {class: nil, cache: ZendeskAPI::LRUCache.new}
       if !options.delete(:reload) && (cached = @resource_cache[method][:cache].read(options.hash))
         cached
       else
@@ -62,21 +66,21 @@ module ZendeskAPI
     # @return [ZendeskAPI::User] Current user or nil
     def current_user(reload = false)
       return @current_user if @current_user && !reload
-      @current_user = users.find(:id => 'me')
+      @current_user = users.find(id: "me")
     end
 
     # Returns the current account
     # @return [Hash] The attributes of the current account or nil
     def current_account(reload = false)
       return @current_account if @current_account && !reload
-      @current_account = SilentMash.new(connection.get('account/resolve').body)
+      @current_account = SilentMash.new(connection.get("account/resolve").body)
     end
 
     # Returns the current locale
     # @return [ZendeskAPI::Locale] Current locale or nil
     def current_locale(reload = false)
       return @locale if @locale && !reload
-      @locale = locales.find(:id => 'current')
+      @locale = locales.find(id: "current")
     end
 
     # Creates a new {Client} instance and yields {#config}.
@@ -93,8 +97,10 @@ module ZendeskAPI
 
       @callbacks = []
       @resource_cache = {}
+      @account_data = {}
 
       check_url
+      check_instrumentation
 
       config.retry = !!config.retry # nil -> false
 
@@ -104,6 +110,25 @@ module ZendeskAPI
       add_warning_callback
     end
 
+    # token impersonation for the scope of the block
+    # @param [String] username The username (email) of the user to impersonate
+    # @yield The block to run while impersonating the user
+    # @example
+    #   client.api_token_impersonate("otheruser@yourcompany.com") do
+    #    client.tickets.create(:subject => "Help!")
+    #   end
+    #
+    #   # creates a ticket on behalf of otheruser
+    # @return
+    # yielded value
+    def api_token_impersonate(username)
+      avant = Thread.current[:zendesk_thread_local_username]
+      Thread.current[:zendesk_thread_local_username] = username
+      yield
+    ensure
+      Thread.current[:zendesk_thread_local_username] = avant
+    end
+
     # Creates a connection if there is none, otherwise returns the existing connection.
     #
     # @return [Faraday::Connection] Faraday connection for the client
@@ -131,6 +156,11 @@ module ZendeskAPI
       end
     end
 
+    def refresh_custom_fields_metadata
+      account_data[:custom_fields] ||= {}
+      ticket_fields.each { |field| account_data[:custom_fields][field.title] = field.id }
+    end
+
     protected
 
     # Called by {#connection} to build a connection. Can be overwritten in a
@@ -146,6 +176,7 @@ module ZendeskAPI
       Faraday.new(config.options) do |builder|
         # response
         builder.use ZendeskAPI::Middleware::Response::RaiseError
+        builder.use ZendeskAPI::Middleware::Response::ZendeskRequestEvent, instrumentation: config.instrumentation, logger: config.logger if config.instrumentation
         builder.use ZendeskAPI::Middleware::Response::Callback, self
         builder.use ZendeskAPI::Middleware::Response::Logger, config.logger if config.logger
         builder.use ZendeskAPI::Middleware::Response::ParseIsoDates
@@ -161,7 +192,7 @@ module ZendeskAPI
         set_authentication(builder, config)
 
         if config.cache
-          builder.use ZendeskAPI::Middleware::Request::EtagCache, :cache => config.cache
+          builder.use ZendeskAPI::Middleware::Request::EtagCache, cache: config.cache, instrumentation: config.instrumentation
         end
 
         builder.use ZendeskAPI::Middleware::Request::Upload
@@ -171,31 +202,41 @@ module ZendeskAPI
         # Should always be first in the stack
         if config.retry
           builder.use ZendeskAPI::Middleware::Request::Retry,
-                      :logger => config.logger,
-                      :retry_codes => config.retry_codes,
-                      :retry_on_exception => config.retry_on_exception
+            logger: config.logger,
+            retry_codes: config.retry_codes,
+            retry_on_exception: config.retry_on_exception,
+            instrumentation: config.instrumentation
         end
         if config.raise_error_when_rate_limited
-          builder.use ZendeskAPI::Middleware::Request::RaiseRateLimited, :logger => config.logger
+          builder.use ZendeskAPI::Middleware::Request::RaiseRateLimited, logger: config.logger
         end
 
         builder.adapter(*adapter, &config.adapter_proc)
+        builder.use ZendeskAPI::Middleware::Request::ApiTokenImpersonate
       end
     end
 
     private
 
     def resource_class_for(method)
-      resource_name = ZendeskAPI::Helpers.modulize_string(Inflection.singular(method.to_s.gsub(/\W/, '')))
+      resource_name = ZendeskAPI::Helpers.modulize_string(Inflection.singular(method.to_s.gsub(/\W/, "")))
       ZendeskAPI::Association.class_from_namespace(resource_name)
     end
 
     def check_url
-      if !config.allow_http && !config.url.start_with?('https://')
+      if !config.allow_http && !config.url.start_with?("https://")
         raise ArgumentError, "zendesk_api is ssl only; url must begin with https://"
       end
     end
 
+    def check_instrumentation
+      return unless config.instrumentation
+
+      unless config.instrumentation.respond_to?(:instrument)
+        raise ArgumentError, "instrumentation must respond to #instrument"
+      end
+    end
+
     def set_raise_error_when_rated_limited
       config.raise_error_when_rate_limited = if config.retry
         false
@@ -217,17 +258,17 @@ module ZendeskAPI
 
     def set_default_logger
       if config.logger.nil? || config.logger == true
-        require 'logger'
+        require "logger"
         config.logger = Logger.new($stderr)
         config.logger.level = Logger::WARN
       end
     end
 
     def add_warning_callback
-      return unless logger = config.logger
+      return unless (logger = config.logger)
 
       insert_callback do |env|
-        if warning = env[:response_headers]["X-Zendesk-API-Warn"]
+        if (warning = env[:response_headers]["X-Zendesk-API-Warn"])
           logger.warn "WARNING: #{warning}"
         end
       end