vid-app-common/src/main/java/org/onap/vid/controller/LoggerController.java

   1 package org.onap.vid.controller;
   2
   3 import ch.qos.logback.classic.LoggerContext;
   4 import ch.qos.logback.core.Appender;
   5 import ch.qos.logback.core.FileAppender;
   6 import ch.qos.logback.core.spi.AppenderAttachable;
   7 import org.apache.commons.io.input.ReversedLinesFileReader;
   8 import org.apache.commons.lang3.StringUtils;
   9 import org.openecomp.portalsdk.core.controller.RestrictedBaseController;
  10 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;
  11 import org.onap.vid.model.ExceptionResponse;
  12 import org.onap.vid.roles.Role;
  13 import org.onap.vid.roles.RoleProvider;
  14 import org.onap.vid.utils.Streams;
  15 import org.slf4j.LoggerFactory;
  16 import org.springframework.beans.factory.annotation.Autowired;
  17 import org.springframework.http.HttpStatus;
  18 import org.springframework.web.bind.annotation.*;
  19
  20 import javax.servlet.http.HttpServletRequest;
  21 import javax.ws.rs.InternalServerErrorException;
  22 import javax.ws.rs.NotAuthorizedException;
  23 import java.io.File;
  24 import java.io.IOException;
  25 import java.util.List;
  26 import java.util.Objects;
  27 import java.util.function.Supplier;
  28 import java.util.stream.Collectors;
  29 import java.util.stream.Stream;
  30
  31 import static com.att.eelf.configuration.Configuration.GENERAL_LOGGER_NAME;
  32
  33
  34 @RestController
  35 @RequestMapping("logger")
  36 public class LoggerController extends RestrictedBaseController {
  37
  38     private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(LoggerController.class);
  39
  40     @Autowired
  41     RoleProvider roleProvider;
  42
  43     @RequestMapping(value = "/{loggerName:audit|error|metrics}", method = RequestMethod.GET)
  44     public String getLog(@PathVariable String loggerName, HttpServletRequest request,
  45                          @RequestParam(value="limit", defaultValue = "5000") Integer limit) throws IOException {
  46
  47         List<Role> roles = roleProvider.getUserRoles(request);
  48         boolean userPermitted = roleProvider.userPermissionIsReadLogs(roles);
  49         if (!userPermitted) {
  50             throw new NotAuthorizedException("User not authorized to get logs");
  51         }
  52
  53         String logfilePath = getLogfilePath(loggerName);
  54
  55         try (final ReversedLinesFileReader reader = new ReversedLinesFileReader(new File(logfilePath))) {
  56             Supplier<String> reverseLinesSupplier = () -> {
  57                 try {
  58                     return reader.readLine();
  59                 } catch (NullPointerException e) {
  60                     // EOF Reached
  61                     return null;
  62                 } catch (IOException e) {
  63                     throw new InternalServerErrorException("error while reading " + logfilePath, e);
  64                 }
  65             };
  66
  67             return Streams.takeWhile(
  68                     Stream.generate(reverseLinesSupplier),
  69                     line -> !StringUtils.contains(line, "Logging is started"))
  70                     .limit(limit)
  71                     .limit(5_000)
  72                     .filter(Objects::nonNull)
  73                     .collect(Collectors.joining("\n"));
  74         }
  75     }
  76
  77     private String getLogfilePath(String loggerName) {
  78         /*
  79         Find the requested logger, and pull all of it's appenders.
  80         Find the first of the appenders that is a FileAppender, and return it's
  81         write-out filename.
  82          */
  83         LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
  84         return context.getLoggerList().stream()
  85                 .filter(logger -> logger.getName().equals(GENERAL_LOGGER_NAME + "." + loggerName))
  86                 .flatMap(this::pullSubAppenders)
  87                 .flatMap(appender -> {
  88                     // Appender might be "attachable", if so - roll-up its sub-appenders
  89                     return (appender instanceof AppenderAttachable) ?
  90                             pullSubAppenders((AppenderAttachable<?>) appender) : Stream.of(appender);
  91                 })
  92                 .filter(appender -> appender instanceof FileAppender)
  93                 .map(appender -> (FileAppender<?>) appender)
  94                 .map(FileAppender::getFile)
  95                 .findFirst()
  96                 .orElseThrow(() -> new InternalServerErrorException("logfile for " + loggerName + " not found"));
  97     }
  98
  99     private <T> Stream<Appender<T>> pullSubAppenders(AppenderAttachable<T> logger) {
 100         return Streams.fromIterator(logger.iteratorForAppenders());
 101     }
 102
 103     @ExceptionHandler({ NotAuthorizedException.class })
 104     @ResponseStatus(HttpStatus.UNAUTHORIZED)
 105     public String notAuthorizedHandler(NotAuthorizedException e) {
 106         return "UNAUTHORIZED";
 107     }
 108
 109     @ExceptionHandler({ IOException.class, InternalServerErrorException.class })
 110     @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
 111     public ExceptionResponse ioExceptionHandler(Exception e) {
 112         return org.onap.vid.controller.ControllersUtils.handleException(e, LOGGER);
 113     }
 114
 115 }