TimEL: Time-series Expression Language
Pick a random example in the
Monitoring, metering, IoT, pay-per-use billing: these are only few examples of applications that rely on time-series data! Often you want the final user to be able to manipulate and customize some results based on some time-series data - that's when TimEL comes in handy!
Keep your data: do not resample your time series
Many time-series systems automatically upscale your value to a certain interval (let's say a value every 60 seconds): this produces a lot of duplicates and also limits granularity: what if there is a value change that lasted for less than 60 seconds? The information will be somehow lost, as it will be blended with some other value to accommodate the 60 second boundary constraint.
TimEL won't force you to do that: it will operate directly using your sample timestamps, regardless of their form (aligned, misaligned, constant interval or variable one) or granularity (anything from years to milliseconds).
The granularity of your samples drives the computation, not the other way around!
Do the right thing: gauges vs integrals (counters)
Some time-series data come as a gauge, while some other come as a counter (integral). TimEL encodes this information directly within its typing system, so you do not have to worry.
Let's imagine you're summing two integral (counter) values: if they're not perfectly aligned, TimEL will automatically interpolate when needed.
TimEL is a Java library to compile and evaluate TimEL expressions. TimEL expressions are written in a user-friendly language that allows time-series manipulation without the need of taking care about upscaling, downscaling or mixing up different time series intervals.
Let's see an expression to count the number of days:
scale( // (3) and then downsample for the whole interval scale( uniform(1.0), // (1) let's take an integral value 1.0 every(1, "DAY_OF_YEAR", "UTC") // (2) repeat it every day ) )
If we evaluate this expression for an interval in the same day, let's say 06:00-18:00, it'll report 0.5 - that is half day. If we evaluate it for more days it
will count how many days are contained in the interval. The function
uniform here returns an integral, so TimEL knows how to interpolate it properly - that
is handled by the interpreter so the user does not need to worry no more about time frames.
With TimEL you can:
- Mix multiple time frames - for example you can sum daily data with hourly data, or even non-regular data like monthly data;
- Express easily recurrent quantities, like 10 units every hour;
- Scale natively integral values (like consumptions) and averages;
- Stream results without the need of having all the operands in memory;
- Support integer, floating point and double expressions;
- Extend with your own types and functions;
- Evaluate expression securely - by default there is no way to access external JVM objects or methods that would expose you to a security risk.
TimEL requires Java 8 and will run in any J2SE or J2EE container. For complete project information, see TimEL's website.
To use TimEL you need to import the following dependency:
<dependency> <groupId>net.vleo.timel</groupId> <artifactId>timel-core</artifactId> <version>0.9.3</version> </dependency>
Now you're ready to go! Let's count how many days passed since (unix) epoch:
// Compile the expression Expression<?> expression = TimEL .parse("scale(scale(uniform(1.0), every(1, \"DAY_OF_YEAR\", \"UTC\")))") .compile(); // Evaluate and print the number of days from epoch Interval interval = Interval.of(Instant.ofEpochMilli(0), Instant.now()); System.out.println(TimEL.evaluate(expression, interval).next());
For a more detailed guide refer to the quickstart guide on TimEL's website.
Extending the language
You can extend TimEL language by adding new types, conversions as well as functions. Refer to the extension page on the homepage.