ios - consumir servicio rest swift 4

¿Cómo puedo registrar cada solicitud/respuesta usando Alamofire?

Question

¿Hay alguna manera de registrar cada solicitud / respuesta usando Alamofire (algo similar a AFNetworkActivityLogger)?

Soy consciente de Printable, DebugPrintable y Output (cURL) pero no son exactamente lo que estoy buscando.

Answer 1

Agregando a la respuesta anterior para Alamofire 4.0+ Swift 3

extension DataRequest {        
        public func LogRequest() -> Self {
        //Your logic for logging
        return self
    }
}

Cuando solicita

Alamofire.request(requestUrl, method: .post, parameters: parameter, encoding: JSONEncoding.default)
            .LogRequest()
            .responseJSON { response in
            //Do your thing
            }

Si desea cancelar la solicitud en cualquier caso (que era algo que yo quería) puede self.cancel() cualquier lugar antes de regresar a sí mismo

Answer 2

Algo como esto podría ser lo que estabas buscando:

extension Request {
   public func debugLog() -> Self {
      #if DEBUG
         debugPrint(self)
      #endif
      return self
   }
}

Uso:

Alamofire.request(.GET, "http://httpbin.org/get", parameters: ["foo": "bar"])
         .debugLog()
         .response {…}

Si desea imprimir todas las respuestas, puede escribir su propio método de respuesta, similar al método responseObject () en la parte superior de este tutorial:

http://www.raywenderlich.com/87595/intermediate-alamofire-tutorial

[Actualización: agregada a continuación según la solicitud de @trauzti.]

Así es como se podría hacer el enfoque responseObject () para imprimir el resultado en cada solicitud.

Lector de advertencias: no he probado personalmente este código, y probablemente tomaría diferentes decisiones en producción. Esto simplemente muestra cómo el código tutorial de Wenderlich puede incluir el registro de depuración. También tenga en cuenta: dado que el tutorial es anterior a Swift 2.0, he usado el antiguo println () en lugar de print ().

@objc public protocol ResponseObjectSerializable {
  init(response: NSHTTPURLResponse, representation: AnyObject)
}

extension Alamofire.Request {
  public func responseObject<T: ResponseObjectSerializable>(completionHandler: (NSURLRequest, NSHTTPURLResponse?, T?, NSError?) -> Void) -> Self {
    let serializer: Serializer = { (request, response, data) in

      #if DEBUG
         println("Request: /(request.URL)")
      #endif

      let JSONSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
      let (JSON: AnyObject?, serializationError) = JSONSerializer(request, response, data)
      if response != nil && JSON != nil {
        #if DEBUG
           println("Response:")
           debugPrint(JSON)
        #endif

        return (T(response: response!, representation: JSON!), nil)
      } else {
        #if DEBUG
           println("Failed Serialization:")
           debugPrint(serializationError)
        #endif

        return (nil, serializationError)
      }
    }

    return response(serializer: serializer, completionHandler: { (request, response, object, error) in
      completionHandler(request, response, object as? T, error)
    })
  }
}

Answer 3

Hay una pequeña y dulce cápsula para esto: https://github.com/konkab/AlamofireNetworkActivityLogger

Agregue esto a su podfile:

pod ''AlamofireNetworkActivityLogger'', ''~> 2.0''

En su AppDelegate:

import AlamofireNetworkActivityLogger

Luego en su didFinishLaunchingWithOptions , agregue esto:

NetworkActivityLogger.shared.level = .debug
NetworkActivityLogger.shared.startLogging()

EDITAR: he encontrado bloqueos con esto en producción. Para estar seguro, usa "indicadores de compilación" para usar solo esto en la depuración, algo como esto:

#if DEBUG
    NetworkActivityLogger.shared.level = .debug
    NetworkActivityLogger.shared.startLogging()
#endif

Answer 4

Timberjack es lo que estás buscando. Timberjack es un registrador de actividad de red simple y poco intrusivo. Registre cada solicitud que hace su aplicación, o limite solo a aquellos que usan cierta sesión de NSURLS, si así lo prefiere. También funciona con Alamofire, si eso es lo tuyo.

https://cocoapods.org/pods/Timberjack

uso:

import Alamofire
import Timberjack

class HTTPManager: Alamofire.Manager {
static let sharedManager: HTTPManager = {
    let configuration = Timberjack.defaultSessionConfiguration()
    let manager = HTTPManager(configuration: configuration)
    return manager
}()
}

Answer 5

SOLUCIÓN PARA SWIFT 3.0+

Para el parámetro y los encabezados de solicitud de impresión:

Alamofire.request(url, method: .get, parameters: parameters, headers: headers)
            .validate()
            .responseObject { (response: DataResponse<T>) in
                self.pendingRequests.removeValue(forKey: endPoint)
                completion!(response)

                if(NetworkConfig.loggingEnable) {
                    debugPrint("************* printing REQUEST parameter and Headers *************")
                    debugPrint("RESPONSE : /(response.debugDescription)")
                }
        }.responseDebugPrint()

Para la respuesta de impresión . use debajo de la extensión

import Foundation
import Alamofire

extension Alamofire.DataRequest {
    func responseDebugPrint() -> Self {
        if NetworkConfig.loggingEnable {

            return responseJSON() {
                response in
                if let  JSON = response.result.value,
                    let JSONData = try? JSONSerialization.data(withJSONObject: JSON, options: .prettyPrinted),
                    let prettyString = NSString(data: JSONData, encoding: String.Encoding.utf8.rawValue) {
                    print(prettyString)
                } else if let error = response.result.error {
                    print("Error Debug Print: /(error.localizedDescription)")
                }
            }
        }
        return self
    }
}

Pequeña idea para usted: https://gist.github.com/manishpathak99/348f2eb0167c0ff6e12ecd667612bc9b/edit