bug fixed

build.gradle

@@ -3,7 +3,8 @@ plugins {
 }
 
 group 'cz.senslog'
-version '1.1-SNAPSHOT'
+version '1.2'
+//version '1.3-SNAPSHOT'
 
 sourceCompatibility = 1.8
 

src/main/java/cz/senslog/analyzer/analysis/module/CollectorHandler.java

@@ -13,7 +13,6 @@ import org.apache.logging.log4j.Logger;
 import java.util.*;
 import java.util.function.Function;
 
-import static cz.senslog.analyzer.domain.TimestampType.LAST_ACCEPTED_INCLUSIVE;
 import static cz.senslog.analyzer.domain.TimestampType.LAST_COMMITTED_INCLUSIVE;
 
 
@@ -97,8 +96,6 @@ public abstract class CollectorHandler<I extends Data<?, ?>> extends BlockingHan
             collectData(newSt.getStatistics()).apply(data);
             groupStatistics.add(statisticsStorage.watch(newSt));
         }
-
-        timestampStorage.update(timestamp, LAST_ACCEPTED_INCLUSIVE);
     }
 
     private static Timestamp createStartOfInterval(Timestamp timestamp, Group group) {

src/main/java/cz/senslog/analyzer/app/Application.java

@@ -3,6 +3,7 @@ package cz.senslog.analyzer.app;
 import cz.senslog.analyzer.analysis.Analyzer;
 import cz.senslog.analyzer.analysis.DaggerAnalyzerComponent;
 import cz.senslog.analyzer.domain.Observation;
+import cz.senslog.analyzer.provider.DataProviderComponent;
 import cz.senslog.analyzer.storage.ConnectionModule;
 import cz.senslog.analyzer.storage.StorageConfig;
 import cz.senslog.analyzer.provider.ProviderConfig;
@@ -77,6 +78,7 @@ public class Application extends Thread {
         try {
             configs = Configuration.load(configFile);
         } catch (IOException e) {
+            logger.error(e.getMessage());
             System.exit(1);
         }
 
@@ -86,21 +88,27 @@ public class Application extends Thread {
 
 
         ConnectionModule connectionModule = ConnectionModule.create(storageConfig);
+        logger.info("Module {} was created successfully.", ConnectionModule.class.getSimpleName());
 
         Analyzer<Observation> analyzer = DaggerAnalyzerComponent.builder()
                 .connectionModule(connectionModule)
                 .build().createNewObservationAnalyzer();
+        logger.info("Component {} was created successfully.", Analyzer.class.getSimpleName());
 
-        DataProvider<Observation> dataProvider = DaggerDataProviderComponent.builder()
-                .connectionModule(connectionModule).build()
-                .scheduledDatabaseProvider()
+
+        DataProviderComponent dataProviderComponent = DaggerDataProviderComponent.builder()
+                .connectionModule(connectionModule).build();
+
+        DataProvider<Observation> dataProvider = dataProviderComponent.scheduledDatabaseProvider()
                 .config(config).deployAnalyzer(analyzer);
+        logger.info("Component {} was created successfully.", DataProvider.class.getSimpleName());
 
         Server server = DaggerServerComponent.builder()
                 .connectionModule(connectionModule).build()
                 .createServer();
+        logger.info("Component {} was created successfully.", Server.class.getSimpleName());
 
         server.start(port);
         dataProvider.start();
     }
-}
+}

src/main/java/cz/senslog/analyzer/app/Configuration.java

@@ -106,6 +106,8 @@ public class Configuration {
         Integer port = (Integer)serverConfigMap.get("port");
 
         StorageConfig storageConfig = new StorageConfig(permanentStConfig, inMemoryStConfig);
+
+        logger.info("Configuration file '{}' was parsed successfully.", fileName);
         return Triple.of(storageConfig, providerConfig, port);
     }
 }

src/main/java/cz/senslog/analyzer/domain/Timestamp.java

@@ -27,7 +27,7 @@ public class Timestamp implements Comparable<Timestamp> {
             .toFormatter();
 
     private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder()
-            .append(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSS"))
+            .append(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
             .optionalStart().appendOffset("+HH", "+00").optionalEnd()
             .toFormatter();
 

src/main/java/cz/senslog/analyzer/domain/TimestampType.java

@@ -1,5 +1,5 @@
 package cz.senslog.analyzer.domain;
 
 public enum TimestampType {
-    FIRST_PROVIDED_INCLUSIVE, LAST_PROVIDED_INCLUSIVE, LAST_PROVIDED_EXCLUSIVE, LAST_ACCEPTED_INCLUSIVE, LAST_COMMITTED_INCLUSIVE
+    FIRST_PROVIDED_INCLUSIVE, LAST_PROVIDED_INCLUSIVE, LAST_PROVIDED_EXCLUSIVE, LAST_COMMITTED_INCLUSIVE
 }

src/main/java/cz/senslog/analyzer/provider/AnalyzerTask.java

@@ -2,12 +2,16 @@ package cz.senslog.analyzer.provider;
 
 
 import cz.senslog.analyzer.analysis.Analyzer;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 import java.util.List;
 import java.util.Objects;
 
 public abstract class AnalyzerTask<T> implements Runnable {
 
+    private static final Logger logger = LogManager.getLogger(AnalyzerTask.class);
+
     private final Analyzer<T> analyzer;
 
     protected AnalyzerTask(Analyzer<T> analyzer) {
@@ -19,6 +23,10 @@ public abstract class AnalyzerTask<T> implements Runnable {
 
     @Override
     public final void run() {
-        this.analyzer.accept(loadData());
+        long startTime = System.currentTimeMillis();
+        analyzer.accept(loadData());
+        long stopTime = System.currentTimeMillis();
+        long durationMilliSec = stopTime - startTime;
+        logger.info("Duration of the task '{}' was {} ms.", getClass().getSimpleName(), durationMilliSec);
     }
 }

src/main/java/cz/senslog/analyzer/provider/task/ObservationAnalyzerTask.java

@@ -7,6 +7,8 @@ import cz.senslog.analyzer.domain.Timestamp;
 import cz.senslog.analyzer.provider.AnalyzerTask;
 import cz.senslog.analyzer.storage.inmemory.TimestampStorage;
 import cz.senslog.analyzer.storage.permanent.repository.SensLogRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 import java.time.OffsetDateTime;
 import java.util.*;
@@ -17,6 +19,8 @@ import static cz.senslog.analyzer.util.ListUtils.sublistToEnd;
 
 public class ObservationAnalyzerTask extends AnalyzerTask<Observation> {
 
+    private static final Logger logger = LogManager.getLogger(ObservationAnalyzerTask.class);
+
     private static final int MAX_OBSERVATIONS = 100;
 
     private final TimestampStorage storage;
@@ -41,23 +45,16 @@ public class ObservationAnalyzerTask extends AnalyzerTask<Observation> {
         Timestamp firstProvided = storage.get(FIRST_PROVIDED_INCLUSIVE, startDateTime);
         Timestamp lastProvidedExclusive = storage.get(LAST_PROVIDED_EXCLUSIVE, Timestamp.MIN);
         Timestamp lastProvidedInclusive = storage.get(LAST_PROVIDED_INCLUSIVE, Timestamp.MIN);
-        Timestamp acceptedInclusive = storage.get(LAST_ACCEPTED_INCLUSIVE, Timestamp.MIN);
         Timestamp committedInclusive = storage.get(LAST_COMMITTED_INCLUSIVE, Timestamp.MIN);
 
-        boolean previousIterationWasProvided = firstProvided.isBefore(lastProvidedExclusive);
-        boolean previousIterationStarted = previousIterationWasProvided && (firstProvided.isBefore(acceptedInclusive) || firstProvided.isEqual(acceptedInclusive));
         boolean previousIterationWasFinished = firstProvided.isBefore(committedInclusive) || firstProvided.isEqual(committedInclusive);
-        boolean previousIterationWasOk = previousIterationWasFinished && committedInclusive.isEqual(acceptedInclusive) && committedInclusive.isEqual(lastProvidedInclusive);
-        boolean previousIterationWasInProgress = previousIterationStarted && !previousIterationWasFinished;
+        boolean previousIterationWasOk = previousIterationWasFinished && committedInclusive.isEqual(lastProvidedInclusive);
 
         List<Observation> newObservations;
 
         if (previousIterationWasOk) {
             newObservations = repository.getObservationsFromTime(lastProvidedExclusive, true, MAX_OBSERVATIONS);
-        } else if (previousIterationWasInProgress) {
-            // TODO a problem of more observations at the same timestamp
-            newObservations = repository.getObservationsFromTime(acceptedInclusive, false, MAX_OBSERVATIONS);
-        } else {
+       } else {
             newObservations = repository.getObservationsFromTime(startDateTime, true, MAX_OBSERVATIONS);
         }
 

src/main/java/cz/senslog/analyzer/storage/permanent/repository/SensLogRepository.java

@@ -43,7 +43,7 @@ public class SensLogRepository {
                                     rs.getLong("sensor_id")
                             ),
                             rs.getDouble("observed_value"),
-                            Timestamp.parse(rs.getString("time_stamp"), POSTGRESQL_TIMESTAMPWTZ_PATTERN)
+                            Timestamp.parse(rs.getString("time_stamp"))
                     )).list()
         );
     }

src/main/java/cz/senslog/analyzer/ws/handler/StatisticsHandler.java

@@ -53,7 +53,7 @@ public class StatisticsHandler extends AbstractRestHandler {
             Optional<IntervalGroup> intervalGroupOpt = Optional.ofNullable(parseIntervalGroup(params.get("interval")));
             if (!intervalGroupOpt.isPresent()) {
                 ctx.fail(400, new Throwable(
-                        "Parameter 'group_by' is not at the correct format. " +
+                        "Parameter 'interval' is not at the correct format. " +
                         "Expected one of these values: "+ Arrays.toString(IntervalGroup.values()) +"."
                 )); return;
             }

src/test/java/cz/senslog/analyzer/domain/TimestampTest.java

@@ -21,5 +21,6 @@ class TimestampTest {
         assertEquals(OffsetDateTime.of(LocalDateTime
                 .of(2019, 12, 31, 23, 0, 0, 319000), ZoneOffset.ofHours(1)).toInstant(),
                 Timestamp.parse("2019-12-31 23:00:00.000319+01").toInstant());
+
     }
 }

src/test/java/cz/senslog/analyzer/provider/task/ObservationAnalyzerTaskTest.java

@@ -91,7 +91,6 @@ class ObservationAnalyzerTaskTest {
         assertEquals(startTime.plusSeconds(2).toInstant(), storage.get(LAST_PROVIDED_EXCLUSIVE).toInstant());
 
         // simulate analyzer
-        storage.update(startTimestamp.plus(2, SECONDS), LAST_ACCEPTED_INCLUSIVE);
         storage.update(startTimestamp.plus(2, SECONDS), LAST_COMMITTED_INCLUSIVE);
 
         // 2. run
@@ -134,7 +133,6 @@ class ObservationAnalyzerTaskTest {
 
         // simulate analyzer
         // data was accepted but not persisted to the database
-        storage.update(startTimestamp.plus(1, SECONDS), LAST_ACCEPTED_INCLUSIVE);
 
         // 2. run
         task.run();

src/test/java/cz/senslog/analyzer/storage/inmemory/repository/TimestampRepositoryTest.java

@@ -29,18 +29,15 @@ class TimestampRepositoryTest {
         repository.update(timestampProvider, LAST_PROVIDED_EXCLUSIVE);
 
         Timestamp timestampAccepted = timestampProvider.plus(1, ChronoUnit.MINUTES);
-        repository.update(timestampAccepted, TimestampType.LAST_ACCEPTED_INCLUSIVE);
 
         Timestamp timestampCommitted = timestampProvider.plus(2, ChronoUnit.MINUTES);
         repository.update(timestampCommitted, TimestampType.LAST_COMMITTED_INCLUSIVE);
 
         assertEquals(timestampProvider.toInstant(), repository.get(LAST_PROVIDED_EXCLUSIVE).toInstant());
-        assertEquals(timestampAccepted.toInstant(), repository.get(LAST_ACCEPTED_INCLUSIVE).toInstant());
         assertEquals(timestampCommitted.toInstant(), repository.get(LAST_COMMITTED_INCLUSIVE).toInstant());
 
         Map<TimestampType, Timestamp> all = repository.getAll();
         assertEquals(timestampProvider.toInstant(), all.get(LAST_PROVIDED_EXCLUSIVE).toInstant());
-        assertEquals(timestampAccepted.toInstant(), all.get(LAST_ACCEPTED_INCLUSIVE).toInstant());
         assertEquals(timestampCommitted.toInstant(), all.get(LAST_COMMITTED_INCLUSIVE).toInstant());
     }
 }