bundles/org.simantics.logging/src/org/simantics/logging/LogCollector.java

   1 package org.simantics.logging;
   2
   3 import java.io.IOException;
   4 import java.nio.file.Files;
   5 import java.nio.file.Path;
   6 import java.nio.file.Paths;
   7 import java.time.LocalDateTime;
   8 import java.time.format.DateTimeFormatter;
   9 import java.util.ArrayList;
  10 import java.util.Collection;
  11 import java.util.Collections;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Map.Entry;
  16
  17 import org.eclipse.core.runtime.Platform;
  18 import org.osgi.framework.InvalidSyntaxException;
  19 import org.osgi.framework.ServiceReference;
  20 import org.simantics.logging.internal.Activator;
  21 import org.simantics.utils.FileUtils;
  22 import org.slf4j.Logger;
  23 import org.slf4j.LoggerFactory;
  24
  25 public final class LogCollector {
  26
  27     private static final Logger LOGGER = LoggerFactory.getLogger(LogCollector.class);
  28
  29     public static Map<String, List<Path>> allLogs() {
  30         Map<String, List<Path>> results = new HashMap<>();
  31         if (LOGGER.isDebugEnabled())
  32             LOGGER.debug("Collecting all logs from declarative services");
  33
  34         Collection<LogProvider> logProviders = getLogProviders();
  35         for (LogProvider logProvider : logProviders) {
  36             List<Path> logs = logProvider.get();
  37             String key = logProvider.getClass().getSimpleName();
  38             Collection<Path> existing = results.get(key);
  39             if (existing != null) {
  40                 LOGGER.info("Duplicate log providers with name {} exist, merging logs", key);
  41                 logs.addAll(existing);
  42             }
  43             results.put(key, logs);
  44         }
  45         if (LOGGER.isDebugEnabled())
  46             LOGGER.debug("Found logs from {} providers", results.keySet());
  47         return results;
  48     }
  49
  50     private static List<LogProvider> getLogProviders() {
  51         ServiceReference<?>[] serviceReferences = new ServiceReference<?>[0];
  52         String key = LogProvider.class.getName();
  53         try {
  54             serviceReferences = Activator.getContext().getAllServiceReferences(key, null);
  55         } catch (InvalidSyntaxException e) {
  56             LOGGER.error("Could not get service references for {}!", key, e);
  57         }
  58         if (serviceReferences.length == 0) {
  59             if (LOGGER.isDebugEnabled())
  60                 LOGGER.debug("No service references found for {}", key);
  61             return Collections.emptyList();
  62         }
  63
  64         List<LogProvider> logProviders = new ArrayList<>(serviceReferences.length);
  65         for (ServiceReference<?> reference : serviceReferences) {
  66             LogProvider logProvider = (LogProvider) Activator.getContext().getService(reference);
  67             logProviders.add(logProvider);
  68         }
  69         if (LOGGER.isDebugEnabled())
  70             LOGGER.debug("Found {} log providers", logProviders);
  71         return logProviders;
  72     }
  73
  74     private static String currentLocalDateTimeStamp() {
  75         return LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HHmm"));
  76     }
  77
  78     public static String archiveFileName() {
  79         StringBuilder fileName = new StringBuilder();
  80         String productName = Platform.getProduct().getName();
  81         if (productName != null)
  82             fileName.append(productName.replaceAll(" ", "_")).append("-");
  83         fileName.append("logs-").append(currentLocalDateTimeStamp());
  84         String result = fileName.toString();
  85         if (LOGGER.isDebugEnabled())
  86             LOGGER.debug("Resolved log files name {}", result);
  87         return result;
  88     }
  89
  90     public static void archiveLogs(String destination) throws IOException {
  91         archiveLogs(Paths.get(destination));
  92     }
  93
  94     private static void archiveLogs(Path destination) throws IOException {
  95         Path tempDir = Files.createTempDirectory(destination.getFileName().toString());
  96         try {
  97             Map<String, List<Path>> allLogs = LogCollector.allLogs();
  98             for (Entry<String, List<Path>> logEntry : allLogs.entrySet()) {
  99                 Path subFolder = tempDir.resolve(logEntry.getKey());
 100                 Files.createDirectory(subFolder);
 101                 for (Path p : logEntry.getValue()) {
 102                     try {
 103                         Files.copy(p, subFolder.resolve(p.getFileName()));
 104                     } catch (IOException e) {
 105                         LOGGER.error("Could not copy {}", p.toAbsolutePath(), e);
 106                     }
 107                 }
 108             }
 109             FileUtils.compressZip(tempDir.toAbsolutePath().toString(), destination.toAbsolutePath().toString());
 110         } finally {
 111             FileUtils.delete(tempDir);
 112         }
 113     }
 114
 115 }