web-dev-qa-db-fra.com

Comment enregistrer le temps pris par le service Web Rest dans Spring Boot?

J'écris un service Web Web Rest à l'aide de Spring Boot .

Je souhaite consigner le temps nécessaire à mon service Web pour traiter la demande . Je souhaite également consigner les en-têtes, la méthode et l'URI appelés.

J'ai fait la même chose dans mon service Web de jersey il y a quelques mois en utilisant ContainerRequestFilter and ContainerResponseFilter filter() method.

Aussi, AOP est mieux ou filtre? 

javaspringloggingspring-boot
7
VdeX

Avez-vous essayé avec un filtre de base comme celui-ci?

import Java.io.IOException;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@WebFilter("/*")
public class StatsFilter implements Filter {

    private static final Logger LOGGER = LoggerFactory.getLogger(StatsFilter.class);

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // empty
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        long time = System.currentTimeMillis();
        try {
            chain.doFilter(req, resp);
        } finally {
            time = System.currentTimeMillis() - time;
            LOGGER.trace("{}: {} ms ", ((HttpServletRequest) req).getRequestURI(),  time);
        }
    }

    @Override
    public void destroy() {
        // empty
    }
}
9
David Pérez Cabrera

Spring Boot: intercepteur de journalisation 

    public class ApiLogger extends HandlerInterceptorAdapter {
        private static final Logger logger = LoggerFactory
                .getLogger(ApiLogger.class);

        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            String requestId = UUID.randomUUID().toString();
            log(request,response, requestId);
            long startTime = System.currentTimeMillis();
            request.setAttribute("startTime", startTime);
            request.setAttribute("requestId", requestId);
            return true;
        }

         @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            super.afterCompletion(request, response, handler, ex);
            long startTime = (Long)request.getAttribute("startTime");

            long endTime = System.currentTimeMillis();

            long executeTime = endTime - startTime;
            logger.info("requestId {}, Handle :{} , request take time: {}",request.getAttribute("requestId"), handler, executeTime);
        }
    private void log(HttpServletRequest request, HttpServletResponse response, String requestId) {
        logger.info("requestId {}, Host {}  HttpMethod: {}, URI : {}",requestId, request.getHeader("Host"),
                request.getMethod(), request.getRequestURI() );
    }
}

enregistrer intercepteur:

@Configuration
@EnableWebMvc
public class AppConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new ApiLogger()).addPathPatterns("/api/v1/*");
    }
}
8
Bhushan Uniyal

La réponse de David est correcte - le filtre est un bon moyen d'implémenter une telle fonctionnalité dans Spring Boot.

Spring Boot a un point de terminaison intégré qui renvoie les informations sur les 100 dernières demandes, comme indiqué ci-dessous:

[{
    "timestamp": 1394343677415,
    "info": {
        "method": "GET",
        "path": "/trace",
        "headers": {
            "request": {
                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
                "Connection": "keep-alive",
                "Accept-Encoding": "gzip, deflate",
                "User-Agent": "Mozilla/5.0 Gecko/Firefox",
                "Accept-Language": "en-US,en;q=0.5",
                "Cookie": "_ga=GA1.1.827067509.1390890128; ..."
                "Authorization": "Basic ...",
                "Host": "localhost:8080"
            },
            "response": {
                "Strict-Transport-Security": "max-age=31536000 ; includeSubDomains",
                "X-Application-Context": "application:8080",
                "Content-Type": "application/json;charset=UTF-8",
                "status": "200"
            }
        }
    }
},{
    "timestamp": 1394343684465,
    ...
}]

Si votre application appelle un autre service ou interroge la base de données, envisagez d'utiliser Sniffy pour le profilage: cela vous indiquera non seulement le temps passé sur votre serveur, mais également le temps passé à appeler des systèmes en aval. Voir une démo en direct ici (Vérifiez le widget noir dans le coin supérieur inférieur). 

Disclaimer: Je suis l'auteur de Sniffy

Sniffy demo screenshot

3
bedrin

Si votre contrôleur est asynchrone, utilisez Aspect pour obtenir le temps d'exécution correct et complet.

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import Java.util.Arrays;
import Java.util.UUID;

@Aspect
@Component
public class LoggingAspect {

  static Logger log = LoggerFactory.getLogger(LoggingAspect.class);

  @Around("execution(* com.aakchoo.api.controller..*(..))")
  public Object profileExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {

    long start = System.currentTimeMillis();
    String className = joinPoint.getSignature().getDeclaringTypeName();
    String methodName = joinPoint.getSignature().getName();
    String apiName = className + "."+ methodName;
    HttpServletRequest request =
        ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
    String requestId = UUID.randomUUID().toString();
    log.info("----->>>>>\nREQUESTED_ID: {}\nHOST: {} HttpMethod: {}\nURI: {}\nAPI: {}\nArguments: {}\n",
        requestId,
        request.getHeader("Host"),
        request.getMethod(),
        request.getRequestURI(),
        apiName,
        Arrays.toString(joinPoint.getArgs()));

    Object result = joinPoint.proceed();
    long elapsedTime = System.currentTimeMillis() - start;
    log.info("<<<<<-----\nExecution Time: {} ms [REQUESTED_ID: {}] [API: {}]", elapsedTime,requestId,apiName);

    return result;
  }
}

Ajoutez @EnableAspectJAutoProxy à votre classe Applciation

@EnableAsync
@SpringBootApplication
@EnableAspectJAutoProxy
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

Et votre build.gradle aura besoin de ce qui suit

compile 'org.aspectj:aspectjweaver:1.8.10'
compile 'org.springframework.boot:spring-boot-starter-aop'
2
aadidasu