lib/fog/aws/iam.rb in fog-1.5.0 vs lib/fog/aws/iam.rb in fog-1.6.0

@@ -9,11 +9,11 @@
       class LimitExceeded < Fog::AWS::IAM::Error; end
       class MalformedCertificate < Fog::AWS::IAM::Error; end
       class ValidationError < Fog::AWS::IAM::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent
+      recognizes :host, :path, :port, :scheme, :persistent, :instrumentor, :instrumentor_name
 
       request_path 'fog/aws/requests/iam'
       request :add_user_to_group
       request :add_role_to_instance_profile
       request :create_access_key
@@ -68,20 +68,20 @@
       request :update_server_certificate
       request :update_signing_certificate
       request :update_user
       request :upload_server_certificate
       request :upload_signing_certificate
-      
+
       model_path 'fog/aws/models/iam'
       model       :user
       collection  :users
       model       :policy
-      collection  :policies      
+      collection  :policies
       model       :access_key
       collection  :access_keys
-      
 
+
       class Mock
         def self.data
           @data ||= Hash.new do |hash, key|
             hash[key] = {
               :owner_id => Fog::AWS::Mock.owner_id,
@@ -149,10 +149,12 @@
           require 'fog/core/parser'
 
           @aws_access_key_id      = options[:aws_access_key_id]
           @aws_secret_access_key  = options[:aws_secret_access_key]
           @connection_options     = options[:connection_options] || {}
+          @instrumentor           = options[:instrumentor]
+          @instrumentor_name      = options[:instrumentor_name] || 'fog.aws.iam'
           @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
           @host       = options[:host]        || 'iam.amazonaws.com'
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
           @port       = options[:port]        || 443
@@ -180,38 +182,42 @@
               :port               => @port,
               :version            => '2010-05-08'
             }
           )
 
-          begin
-            response = @connection.request({
-              :body       => body,
-              :expects    => 200,
-              :idempotent => idempotent,
-              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
-              :host       => @host,
-              :method     => 'POST',
-              :parser     => parser
-            })
+          if @instrumentor
+            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
+              _request(body, idempotent, parser)
+            end
+          else
+            _request(body, idempotent, parser)
+          end
+        end
 
-            response
-          rescue Excon::Errors::HTTPStatusError => error
-            if match = error.message.match(/<Code>(.*)<\/Code>(?:.*<Message>(.*)<\/Message>)?/m)
-              case match[1]
-              when 'CertificateNotFound', 'NoSuchEntity'
-                raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
-              when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
-                raise Fog::AWS::IAM.const_get(match[1]).slurp(error, match[2])
-              else
-                raise Fog::AWS::IAM::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
-                raise
-              end
+        def _request(body, idempotent, parser)
+          @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :idempotent => idempotent,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+            :host       => @host,
+            :method     => 'POST',
+            :parser     => parser
+          })
+        rescue Excon::Errors::HTTPStatusError => error
+          if match = error.message.match(/<Code>(.*)<\/Code>(?:.*<Message>(.*)<\/Message>)?/m)
+            case match[1]
+            when 'CertificateNotFound', 'NoSuchEntity'
+              raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
+            when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
+              raise Fog::AWS::IAM.const_get(match[1]).slurp(error, match[2])
             else
+              raise Fog::AWS::IAM::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
               raise
             end
+          else
+            raise
           end
-
-
         end
 
       end
     end
   end