Further work

Author: Russoul

timeseries-io/app/Main.hs

@@ -3,20 +3,54 @@
 
 module Main where
 
+import           Cardano.Timeseries.Import.PlainCBOR
 import           Cardano.Timeseries.Query (interp)
 import           Cardano.Timeseries.Query.Parser (expr)
+import           Cardano.Timeseries.Query.Value (Error, Value)
 import           Cardano.Timeseries.Store
 import           Cardano.Timeseries.Store.Flat (Flat, Point (instant, name))
 import           Cardano.Timeseries.Store.Parser (points)
 
+import           Control.Monad (forever)
+import           Control.Monad.Except (runExceptT)
+import           Control.Monad.State.Strict (evalState)
 import           Data.Attoparsec (skipMany)
-import           Data.Attoparsec.Text (decimal, parseOnly, space)
+import           Data.Attoparsec.Text (decimal, endOfInput, parseOnly, space)
+import           Data.Foldable (for_, traverse_)
 import           Data.Text (pack)
 import           GHC.List (foldl')
 import           System.Exit (die)
+import           System.IO (hFlush, stdout)
+
+snapshotsFile :: String
+snapshotsFile = "6nodes_4hours_1mininterval.cbor"
+
+printStore :: Flat Double -> IO ()
+printStore = traverse_ print
+
+printQueryResult :: Either Error Value -> IO ()
+printQueryResult (Left err) = putStrLn ("Error: " <> err)
+printQueryResult (Right ok) = print ok
+
+interactive :: Flat Double -> IO ()
+interactive store = forever $ do
+ putStr "> "
+ hFlush stdout
+ queryString <- getLine
+ case parseOnly (expr <* skipMany space <* endOfInput) (pack queryString) of
+   Left err -> putStrLn err
+   Right query -> do
+     putStrLn ("Expr: " <> show query)
+     printQueryResult (evalState (runExceptT $ interp store mempty query 0) 0)
 
 main :: IO ()
 main = do
+  content <- readFileSnapshots snapshotsFile
+  let store = snapshotsToFlatStore content
+  interactive store
+
+main1 :: IO ()
+main1 = do
   putStrLn "This is a prototype!"
   string <- readFile "dataset.txt"
   let result = parseOnly (points decimal <* skipMany space) (pack string)
@@ -26,12 +60,12 @@ main = do
       print (dataset :: [Point Integer])
       let store = foldl' (\s p -> insert s (name p) (instant p)) (new :: Flat Double) (fmap (fmap fromIntegral) dataset)
       string <- readFile "expression.txt"
-      let result = parseOnly (expr <* skipMany space) (pack string)
+      let result = parseOnly (expr <* skipMany space <* endOfInput) (pack string)
       case result of
         Left err -> die err
         Right expr -> do
           print expr
-          
+
           -- no instance Show Value
           -- print $ interp store expr 15
 

timeseries-io/dataset.txt

@@ -0,0 +1,108 @@
+// WIP: In case we want some ambiguity in the surface language
+
+fst t
+snd t
+(t, t)
+t == t
+t < t
+t <= t
+t > t
+t >= t
+t + t
+t - t
+t * t
+t / t
+not a
+a && b
+a || b
+\x -> t
+minutes n
+hours n
+epoch
+now
+rewind t d
+fast_forward t d
+toScalar t
+s[t; t]
+s[t; t; t]
+v{ls}
+max t
+avg t
+filter t t
+t ⊗ t
+t t
+abs t : Scalar
+increase t
+rate t
+avg_over_time t
+sum_over_time t
+quantile_over_time t t
+unless t t
+quantile-by ls t t
+
+Γ |- t ~> t' ∈ (A, B)
+------------------------
+Γ |- fst t ~> fst t' ∈ A
+
+
+Γ |- t ~> t' ∈ (A, B)
+-------------------
+Γ |- snd t ~> snd t' ∈ B
+
+
+Γ |- a ~> a' ∈ A
+Γ |- b ~> b' ∈ B
+--------------------------------
+Γ |- (a, b) ~> (a', b') ∈ (A, B)
+
+
+Γ |- a₀ ~> a₀' ∈ A
+Γ |- a₁ ~> a₁' ∈ B
+Γ |- A = B = Scalar
+------------------------------------
+Γ |- a₀ == a₁ ~> eq_scalar a₀' a₁' ∈ Scalar
+
+
+Γ |- a₀ ~> a₀' ∈ A
+Γ |- a₁ ~> a₁' ∈ B
+Γ |- A = B = Bool
+---------------------------------------
+Γ |- a₀ == a₁ ~> eq_bool a₀' a₁' ∈ Bool
+
+
+Γ |- a₀ ~> a₀' ∈ Scalar
+Γ |- a₁ ~> a₁' ∈ Scalar
+-----------------------------------------
+Γ |- a₀ < a₁ ~> lt_scalar a₀' a₁' ∈ Scalar
+
+
+Γ |- a₀ ~> a₀' ∈ InstantVector Scalar
+Γ |- a₁ ~> a₁' ∈ Scalar
+-----------------------------------------------------------------------
+Γ |- a₀ < a₁ ~> lt_instant_vector_scalar a₀' a₁' ∈ InstantVector Scalar
+
+
+Γ |- a₀ ~> a₀' ∈ Scalar
+Γ |- a₁ ~> a₁' ∈ Scalar
+----------------------------------------
+Γ |- a₀ + a₁ ~> add_scalar a₀ a₁ ∈ Scalar
+
+
+Γ |- a₀ ~> a₀' ∈ InstantVector Scalar
+Γ |- a₁ ~> a₁' ∈ InstantVector Scalar
+----------------------------------------------------------------------
+Γ |- a₀ + a₁ ~> add_instant_vector_scalar a₀ a₁ ∈ InstantVector Scalar
+
+
+Γ |- v ∋ Timestamp -> InstantVector Scalar
+Γ |- a ∋ Timestamp
+Γ |- b ∋ Timestamp
+------------------------------------------
+Γ |- v[a, b] ∈ RangeVector Scalar
+
+Γ |- v ∋ Timestamp -> InstantVector Scalar
+Γ |- a ∋ Timestamp
+Γ |- b ∋ Timestamp
+Γ |- d ∋ Duration
+------------------------------------------
+Γ |- v[a, b, d] ∈ RangeVector Scalar

timeseries-io/elab.txt

@@ -0,0 +1,6 @@
+module Cardano.Timeseries.Domain.Identifier(Identifier(..)) where
+
+-- | Identifiers come in two sorts: Userspace and Machine-generated.
+-- | The first kind comes from user-typed expressions.
+-- | The second kind is used for automatic code-generation for hygienic scoping (i.e. to avoid unintentional variable capture)
+data Identifier = User !String | Machine !Int deriving (Show, Ord, Eq)

timeseries-io/expression.txt

@@ -4,16 +4,18 @@ import           Cardano.Timeseries.Domain.Types (SeriesIdentifier, Timestamp)
 
 import           Data.Vector
 
+-- | One datapoint in a series.
 data Instant a = Instant {
-  labels :: SeriesIdentifier,
-  timestamp :: Timestamp,
-  value :: a
+  labels :: !SeriesIdentifier,
+  timestamp :: !Timestamp,
+  value :: !a
 } deriving (Show, Eq, Functor, Foldable, Traversable)
 
 -- | Do the instant vectors share a series?
 share :: Instant a -> Instant b -> Bool
 share a b = labels a == labels b
 
+-- | Datapoints from different series. The vector must not contain datapoints sharing a series.
 type InstantVector a = [Instant a]
 
 mostRecent :: Instant a -> Instant a -> Instant a

timeseries-io/src/Cardano/Timeseries/Domain/Identifier.hs

@@ -4,9 +4,10 @@ import           Cardano.Timeseries.Domain.Types (Timestamp)
 
 import           Prelude hiding (length)
 
+-- | A time interval. Assumption: `start` ≤ `end`
 data Interval = Interval {
-  start :: Timestamp,
-  end :: Timestamp
+  start :: !Timestamp,
+  end :: !Timestamp
 } deriving (Show, Eq)
 
 length :: Interval -> Double

timeseries-io/src/Cardano/Timeseries/Domain/Instant.hs

@@ -13,9 +13,10 @@ import qualified Data.Set as Set
 import           Data.Vector (Vector)
 import qualified Data.Vector as Vector
 
+-- | A collection of datapoints sharing a series.
 data Timeseries a = Timeseries {
-  labels :: SeriesIdentifier,
-  dat :: [(Timestamp, a)]
+  labels :: !SeriesIdentifier,
+  dat :: ![(Timestamp, a)]
 } deriving (Show, Functor, Foldable, Traversable)
 
 oldest :: Timeseries a -> Maybe (Instant a)

timeseries-io/src/Cardano/Timeseries/Domain/Interval.hs

@@ -9,6 +9,8 @@ import           Data.Word (Word64)
 type MetricIdentifier = String
 
 type Label = String
+
+-- | Key-value pair of a label and its value.
 type Labelled a = (Label, a)
 
 -- | Series is identified by a set of labels. Hence the name.

timeseries-io/src/Cardano/Timeseries/Domain/Timeseries.hs

@@ -1,15 +1,20 @@
 {-# LANGUAGE DeriveAnyClass #-}
 {-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE TypeSynonymInstances #-}
 
 {-# OPTIONS_GHC -Wno-type-defaults -Wno-orphans #-}
 
 module Cardano.Timeseries.Import.PlainCBOR where
 
+import           Cardano.Timeseries.Domain.Instant (Instant (..))
+import           Cardano.Timeseries.Store.Flat (Flat, Point (..))
+
 import           Codec.Serialise
 import           Control.Applicative
+import           Control.Monad (join)
 import           Data.Map.Strict as Map (Map, size)
+import qualified Data.Map.Strict as Map
+import qualified Data.Set as Set
 import           Data.Text (Text, unpack)
 import           Data.Time.Clock.POSIX (POSIXTime)
 import           GHC.Generics (Generic)
@@ -29,7 +34,7 @@ data Snapshot = Snapshot
   deriving (Generic, Serialise)
 
 instance Show Snapshot where
-  show (Snapshot l t s) = "Snapshot{" ++ unpack l ++ "} @ " ++ show t ++ ", entries: " ++ show (Map.size s)
+  show (Snapshot l t s) = "Snapshot{" ++ unpack l ++ "} @ " ++ show t ++ ", entries: " ++ show s
 
 
 instance Serialise POSIXTime where
@@ -40,6 +45,20 @@ instance Serialise POSIXTime where
 readFileSnapshots :: FilePath -> IO [Snapshot]
 readFileSnapshots = readFileDeserialise
 
+numericValueToDouble :: NumericValue -> Double
+numericValueToDouble (NVInt x) = fromIntegral x
+numericValueToDouble (NVDouble x) = x
+
+scrapeDatapointToPoint :: Text -> POSIXTime -> Text -> NumericValue -> Point Double
+scrapeDatapointToPoint node t metric v =
+  Point (unpack metric) (Instant (Set.fromList [("node", unpack node)]) (floor (t * 1000)) (numericValueToDouble v))
+
+snapshotToFlatStore :: Snapshot -> Flat Double
+snapshotToFlatStore (Snapshot l t s) = Map.foldlWithKey' (\acc k v -> scrapeDatapointToPoint l t k v : acc) [] s
+
+snapshotsToFlatStore :: [Snapshot] -> Flat Double
+snapshotsToFlatStore = (>>= snapshotToFlatStore)
+
 -- can be used with Data.List.sortBy
 snapshotOrd :: Snapshot -> Snapshot -> Ordering
 snapshotOrd a b =