Enregistrement de l'hôte distant dans Finagle

Question

Je souhaite connecter l'hôte distant appelé à STDOUT lors de l'utilisation de Finagle Client. Mais autant que je vois ce n'est pas possible via com.twitter.finagle.http.filter.LoggingFilter; Son #format (par exemple voir ci-dessous) méthode ne peut pas accéder à l'hôte réel:

• request.remoteHost() retours 0.0.0.0
• request.remoteAddress() retourne un objet qui contient essentiellement ci-dessus IP
• request.host() retourne un objet None

Ma première supposition est/était que l'accès à l'hôte n'est pas possible car L'équilibrage de la charge côté client de Finagle est plus profond dans la pile.

C'est le code de test que j'utilise:

LoggingFilter<Request> loggingFilter = new LoggingFilter<>(
      new Logger(this.getClass().getSimpleName(), java.util.logging.Logger.getLogger(this.getClass().getSimpleName())), 

      new LogFormatter<Request, Response>() { 
       @Override 
       public String format(Request request, Response reply, Duration replyTime) { 
        return null; 
       } 

       @Override 
       public String formatException(Request request, Throwable throwable, Duration replyTime) { 
        return null; 
       } 
      }); 

    Service<Request, Response> service = Http.client().newService("localhost:8090,localhost:8091"); 
    Future<Response> response = loggingFilter.andThen(service).apply(Request.apply("/profiles/me")); 

Answer 1

Le critère d'évaluation réelle à laquelle la demande est envoyée est décidé dans l'équilibreur de charge. Donc en effet, la journalisation de l'hôte distant ne peut se faire qu'après le module d'équilibrage de charge.

Le module d'équilibrage de charge rend le paramètre Transporter.EndpointAddr disponible. Ce paramètre contient l'adresse réelle. Pour utiliser ce paramètre, vous devez ajouter un module à la pile de clients HTTP, juste après le module d'équilibrage de charge.

Un exemple à Scala:

Créer votre filtre de journalisation:

class MyLoggingFilter(addr: Address) extends SimpleFilter[Request, Response] { 
    override def apply(request: Request, service: Service[Request, Response]) = { 
    println(s"Sending request to $addr") 
    service(request) 
    } 
} 

Définir le nouveau module

def endpointLoggerModule: Stackable[ServiceFactory[Request, Response]] = 
    new Stack.Module1[Transporter.EndpointAddr, ServiceFactory[Request, Response]] { 
    val role: Role = Role("EndpointLogger") 
    val description = "Log remote address" 
    def make(_addr: Transporter.EndpointAddr, 
      next: ServiceFactory[Request, Response]) = { 
     val Transporter.EndpointAddr(addr) = _addr 
     new MyLoggingFilter(addr).andThen(next) 
    } 
    } 

Créer un nouveau client Http avec ce module dans la pile:

val stackWithLogging = Http.client.stack 
    .insertAfter(LoadBalancerFactory.role, endpointLoggerModule) 
val service = Http.client.copy(stack = stackWithLogging) 
    .newService("localhost:8090,localhost:8091") 

Ce service créé doit ensuite enregistrer les adresses réelles auxquelles les demandes sont envoyées.

Plus d'informations à propos de Composition de modules peut être trouvé à: https://twitter.github.io/finagle/guide/Clients.html?highlight=module#module-composition