Merge pull request #197 from wttech/log-timestamps

Log timestamps

Author: krystian-panek-vmltech

core/src/main/java/dev/vml/es/acm/core/code/CodeLoggerPrinter.java

@@ -2,9 +2,19 @@
 
 import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.AppenderBase;
+import dev.vml.es.acm.core.AcmException;
 import java.io.OutputStream;
 import java.io.PrintStream;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
+import org.apache.commons.lang3.StringUtils;
 import org.slf4j.LoggerFactory;
 
 /**
@@ -13,17 +23,101 @@
  */
 public class CodePrintStream extends PrintStream {
 
+    public static final String LOGGER_NAME_ACL = "dev.vml.es.acm.core.acl";
+    public static final String LOGGER_NAME_REPO = "dev.vml.es.acm.core.repo";
+    public static final String[] LOGGER_NAMES = {LOGGER_NAME_ACL, LOGGER_NAME_REPO};
+
+    // have to match pattern in 'monaco/log.ts'
+    private static final DateTimeFormatter LOGGER_TIMESTAMP_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");
+
     private final Logger logger;
 
-    private final CodeLoggerPrinter loggerPrinter;
+    private final LoggerContext loggerContext;
+
+    private final Set<String> loggerNames;
+
+    private boolean loggerTimestamps;
+
+    private final LogAppender logAppender;
 
     public CodePrintStream(OutputStream output, String id) {
         super(output);
 
-        LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
-
-        this.loggerPrinter = new CodeLoggerPrinter(loggerContext, output);
+        this.loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
+        this.loggerNames = new HashSet<>();
+        this.loggerTimestamps = true;
         this.logger = loggerContext.getLogger(id);
+        this.logAppender = new LogAppender();
+    }
+
+    private class LogAppender extends AppenderBase<ILoggingEvent> {
+        @Override
+        protected void append(ILoggingEvent event) {
+            String loggerName = event.getLoggerName();
+            for (String loggerPrefix : loggerNames) {
+                if (StringUtils.startsWith(loggerName, loggerPrefix)) {
+                    String level = event.getLevel().toString();
+                    if (loggerTimestamps) {
+                        LocalDateTime eventTime = LocalDateTime.ofInstant(
+                                Instant.ofEpochMilli(event.getTimeStamp()), ZoneId.systemDefault());
+                        String timestamp = eventTime.format(LOGGER_TIMESTAMP_FORMATTER);
+                        println(timestamp + " [" + level + "] " + event.getFormattedMessage());
+                    } else {
+                        println('[' + level + "] " + event.getFormattedMessage());
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    public void fromLogger(String loggerName) {
+        if (StringUtils.isBlank(loggerName)) {
+            throw new AcmException("Logger name cannot be blank!");
+        }
+        enableAppender();
+        loggerNames.add(loggerName);
+    }
+
+    @Override
+    public void close() {
+        disableAppender();
+        super.close();
+    }
+
+    private void enableAppender() {
+        if (logAppender.isStarted()) {
+            return;
+        }
+        Logger rootLogger = getRootLogger();
+        rootLogger.addAppender(logAppender);
+        logAppender.setContext(loggerContext);
+        logAppender.start();
+    }
+
+    private void disableAppender() {
+        if (!logAppender.isStarted()) {
+            return;
+        }
+        logAppender.stop();
+        Logger rootLogger = getRootLogger();
+        rootLogger.detachAppender(logAppender);
+    }
+
+    private Logger getRootLogger() {
+        return loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
+    }
+
+    public Logger getLogger() {
+        return logger;
+    }
+
+    public boolean isLoggerTimestamps() {
+        return loggerTimestamps;
+    }
+
+    public void withLoggerTimestamps(boolean flag) {
+        this.loggerTimestamps = flag;
     }
 
     public void fromLogs() {
@@ -40,11 +134,7 @@ public void fromSelfLogger() {
     }
 
     public void fromRecommendedLoggers() {
-        fromLoggers(CodeLoggerPrinter.NAMES);
-    }
-
-    public void fromLogger(String loggerName) {
-        loggerPrinter.fromLogger(loggerName);
+        fromLoggers(LOGGER_NAMES);
     }
 
     public void fromLoggers(String... loggerNames) {
@@ -56,14 +146,4 @@ public void fromLoggers(String... loggerNames) {
     public void fromLoggers(List<String> loggerNames) {
         loggerNames.forEach(this::fromLogger);
     }
-
-    @Override
-    public void close() {
-        loggerPrinter.disable();
-        super.close();
-    }
-
-    protected Logger getLogger() {
-        return logger;
-    }
 }

core/src/main/java/dev/vml/es/acm/core/code/CodePrintStream.java

@@ -54,7 +54,12 @@ public class Executor {
         @AttributeDefinition(
                 name = "Log Printing Names",
                 description = "Additional loggers to print logs from (class names or package names)")
-        String[] logPrintingNames() default {CodeLoggerPrinter.NAME_ACL, CodeLoggerPrinter.NAME_REPO};
+        String[] logPrintingNames() default {CodePrintStream.LOGGER_NAME_ACL, CodePrintStream.LOGGER_NAME_REPO};
+
+        @AttributeDefinition(
+                name = "Log Printing Timestamps",
+                description = "Prints timestamps in the execution output.")
+        boolean logPrintingTimestamps() default true;
 
         @AttributeDefinition(
                 name = "Notification Enabled",
@@ -170,6 +175,7 @@ private ImmediateExecution executeImmediately(ExecutionContext context) {
                 if (config.logPrintingEnabled()) {
                     context.getOut().fromSelfLogger();
                     context.getOut().fromLoggers(config.logPrintingNames());
+                    context.getOut().withLoggerTimestamps(config.logPrintingTimestamps());
                 }
                 contentScript.run();
                 return execution.end(ExecutionStatus.SUCCEEDED);

core/src/main/java/dev/vml/es/acm/core/code/Executor.java

@@ -15,11 +15,11 @@ export function registerLogLanguage(instance: Monaco) {
   instance.languages.setMonarchTokensProvider(LOG_LANGUAGE_ID, {
     tokenizer: {
       root: [
-        [/^\[ERROR].*$/, 'log-error'],
-        [/^\[WARN].*$/, 'log-warn'],
-        [/^\[INFO].*$/, 'log-info'],
-        [/^\[DEBUG].*$/, 'log-debug'],
-        [/^\[TRACE].*$/, 'log-trace'],
+        [/^(\d{2}:\d{2}:\d{2}\.\d{3} )?\[ERROR\].*$/, 'log-error'],
+        [/^(\d{2}:\d{2}:\d{2}\.\d{3} )?\[WARN\].*$/, 'log-warn'],
+        [/^(\d{2}:\d{2}:\d{2}\.\d{3} )?\[INFO\].*$/, 'log-info'],
+        [/^(\d{2}:\d{2}:\d{2}\.\d{3} )?\[DEBUG\].*$/, 'log-debug'],
+        [/^(\d{2}:\d{2}:\d{2}\.\d{3} )?\[TRACE\].*$/, 'log-trace'],
       ],
     },
   });