Search
TRY ME

Try Valo for free

We want to show you something amazing.

We'll send you a link to download a fully functional Valo copy to play with.

Loader
Success

Great! Check your email and enjoy Valo

Error

Apologies, we seem to be having a problem processing your input, please try again

SCALABLE AND RESILIENT BIG DATA ANALYTICS

Combining analytical functions and machine learning with an advanced execution engine and big data storage

It’s fast, seriously fast

Valo’s unique architecture and stream processing ability mean this system truly is real-time. No close to real-time or nearly real-time, it’s really real-time. No (micro) batches here.

Built-in algorithms and BYO

In-built analytical functions, such as time windows and machine learning algorithms allow you to perform complex analysis including anomaly detection on time series data.

Big data storage

Specialised storage engines take advantage of the immutable and append only data model to optimally index and retrieve time series and semi-structured data.

Highly available and scalable

All nodes have their own computation and storage ability making Valo scalable and resilient, while maintaining high throughput and low latency.

All of your data and analytics in one place

Multiple sources and types of data are easily ingested and query results can be used to create new streams of data to query against.

Open API

Valo uses a REST API making it easy to integrate with your existing tools and architectures for both input and output of your data and analytics.

Familiar SQL-like language

The SQL-like language makes it easy to write simple, or complex, queries.

Multiplatform

Windows, Linux, Mac are supported. If you can run Java on your platform, you’ll be able to get the power of Valo on it.

VALO'S DECENTRALISED CLUSTER

The clustered node architecture makes Valo resilient and elastic, meaning it can be easily scaled up and back as required. Simply increase the number of nodes to increase the number of queries, streams and contributors processed.

Scalable

The clustered node architecture makes Valo resilient and elastic, meaning it can be easily scaled up and back as required. Simply increase the number of nodes to increase the number of queries, streams and contributors processed.

Scalable

Every node is equal in its ability to store, process streams and analyse data. This means less data movement is required, making computations faster and providing higher performance for distributed computing.

Capable

Valo is an AP system, prioritising availability and partition tolerance. If a node goes down, the failed part of the system is partitioned off and Valo continues to process data successfully across the remaining system.

Available

SEE VALO IN ACTION

WATCH VIDEO

DEVELOPERS

For evaluation or application development only. Single Node with no clustering

TRY ME

PRODUCTION

For all production usage, including maintenance and support.

CONTACT US
VERSION 1.3 Nov 04, 2016

We are pleased to announce that Valo version 1.3 is now available for download. This release includes; enhancements to better support ingestion of large amounts of data from external sources and large CSV data sets, further optimisation of disk and memory usage for better data organisation and storage, as well as the ability to perform joins on queries that contain aggregations. We’ve also taken on board feedback from users to fix those pesky bugs.

 

Transport improvements

Improvements have been made to the way Valo ingests data from external sources, such as ITRS Geneos.  Higher rates of data ingestion will no longer cause poll messages to stack up, eventually causing an out of memory exception.

 

Symbol type

A new subset of the string type, Symbol has been added.  Symbols are atomic case sensitive strings representing an identifier (such as an error or status code).  Unlike regular strings, symbols are never tokenised, but are indexed as-is in their entirety.  This dramatically reduces the storage requirements for these texts, but means they cannot be partially searched for; thus an “InvalidParameter” symbol would not be found by a search for “Invalid”.

 

Symbols are defined by setting the type-params of the text type.  E.g.:

 


{
    “type”: “string”,
    “type-params”: {
        “sub-type”: “symbol”
    }
}

 

Asian language analysers

Streams can now be configured with different language analysers and will be indexed accordingly.  This will allow character-based languages such as Chinese to be searched correctly.

 

Improved messaging

Information and error messages have been significantly improved to more easily resolve issues such as invalid queries and references.

 

Other highlights

  • Disk and memory usage has been further improved
  • Joins can now be performed on queries that contain aggregations
  • Large CSV data sets can now be written without causing an out of memory exception
  • The execution engine output now contains the node address so that it can be referred to outside a firewall
  • Time-series repository write failures (such as when the disk runs out of space) are now rolled back to the last known good state
  • Temporary network failures will not cause nodes to be marked as permanently unavailable
  • Boolean expressions are now correctly aliased, allowing queries like from /streams/demo/infrastructure/cpu select user > 10
  • Distribution policy documents with numbers passed as strings will be interpreted correctly

We’re always keen to hear about your experiences using Valo and any suggestions on new features you would like to be considered for future releases, so please get in touch.


DOWNLOAD
VERSION 1.2 Jul 20, 2016

Valo 1.2 is now released.  This release is packed full of new features, primarily around scalability, resilience and improvements to the back end infrastructure of Valo, plus a multitude of fixes in all areas of the application.

 

Command line interface improvements

The Valo executable has been renamed from valo-cluster-app to simply valo. The command line interface has also been significantly improved, particularly when managing larger clusters.  

Full documentation running Valo and the relevant command line arguments can be found here.

 

Full clustering support

Previously we were recommending single node clusters for testing purposes.  This restriction is now lifted, and Valo fully supports multi-node clusters.  For best performance we recommend keeping one node per physical box though there is no restriction on running multiple nodes on a single machine for testing.

 

Dynamic scaling

Nodes can now be added and removed from a cluster dynamically using the new command line interface.  This will not affect the flow of data into the Valo cluster and the repositories will be rebalanced automatically.  Provided sufficient data redundancy has been configured, this will not result in any data loss.

 

Data atomicity

Writes in Valo are now guaranteed atomically, which means that events such as power outage or hardware failure will not result in data corruption or loss.

 

Extended character support

Character support for streams, fields and custom functions has been extended.  These are now case-sensitive and support unicode characters, with the following restrictions:

  • Fields cannot start with __ (2 underscores) These are considered ‘private’
  • Cannot be an expressions constant: (true, false) in any case
  • Cannot be an operator: +, -, *, /, %, ||, &&, !, >=, <=, !=, ==, >, <, NOT, and, or
  • Cannot contain any operator symbol: +, -, *, /, %, ||, &&, !, >=, <=, !=, ==, >, <
  • All characters must be valid java identifier characters, where Character.isJavaIdentifierPart is true

 

Breaking changes

Please note that due to the scale and scope of the new features in 1.2, there have been a number of breaking changes to the repository.  When performing an upgrade, first remove the old version completely, using the data tool to back up the repositories if necessary, then install Valo 1.2.  Any backed up data can then be reimported using the data tool.  In-place upgrades will not work between 1.2 and earlier versions.

The configuration file, application.conf, has also been improved significantly with new parameters and options.  These are documented inline.

 

Other highlights

  • Disk and memory usage has been significantly improved
  • Query nodes provide better error handling so that malformed data will not cause a query to abort
  • The standard query operators (such as +, -, ==, and !=) now handle null and missing values.
  • Different data types such as int, shorts and strings are now automatically converted when required for certain query functions
  • The output of certain streaming algorithms such as TopK can now be chained using additional selects
  • The TopK algorithm now consumes significantly less memory
  • TopK can now be performed against historical data
  • Historical SSR queries will now execute significantly faster
  • Historical SSR queries will perform correctly when grouped by a contributor
  • Subtracting datetimes is now performed in the correct order
  • Dates and datetimes can be compared correctly
  • Additional information such as OS and JVM versions are now available in the application log file
  • Unsorted SSR data is now handled correctly when executed in a time window
  • Daemonised queries are now persisted when Valo is restarted
  • All REST requests can be logged to a file if the parameter valo.frontend.debug.dump-all-requests is set in application.conf
  • CSVs with empty columns will no longer cause a memory overflow
  • POSTing to a stream that does not exist now returns 404
  • When starting a node, front-end services are initialised last, after any data transfers have been completed
  • Large log files will now be rolled over into the correct folder
  • Large payloads no longer cause extremely slow SSR queries
  • The SSR now only loads the stream schema when the local node is reachable (e.g. has joined the cluster)
  • Unreachable nodes no longer cause certain queries to time out
  • Port collisions are now handled gracefully
  • Information and debug messages are no longer logged by default
  • Extremely large data sets no longer cause an out of memory exception under certain circumstances Sorting is now done using a disk-based buffer, avoiding an out of memory exception on large data sets