redis-time-series 0.2.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51234a8f3542da255912f95982ebab2bf66dd657da9e38e55afdedd97029685d
-  data.tar.gz: 42a49fdafb136d8ebe4b094f935b0427430672ab810691a35ca2f78328d92135
+  metadata.gz: 461a6f3842867d1ba51440e7576aad3e9b92ecd02700cd59e5508c0e8bbfcaa7
+  data.tar.gz: 0c03af91af0eaaa37917db2cad21417c38709a53b223ed2864bad0f9857fa1f7
 SHA512:
-  metadata.gz: acc08d1745cf24bfc87c22d3809570daa0b2feae4e5d5b97d4a43a0626217b44ea3ffdb12c3f6799c068bb6e62f0cc7a1b65274e5d8eac5cb13017bfea73dff4
-  data.tar.gz: 1ff7aa6fb44dd2729612ac24e2be45496d45bd5a0fc86ed692bd18c38bcb160971c0efed05e598ffabb6471cf4d6903d303a1d0b74e55672c479829b98b26012
+  metadata.gz: 56dcd4439b2f4f06469237d2925d84b2ffabc40e2dccb608d5489b78f0e2a5b299881487b55e67fb48f1c9d0f7f56951ee98254ae84229b1827fb4cf3683ca44
+  data.tar.gz: 860e638f906b9dc19358e6156ad6a0488452be0be499853926742073cf6e85d00f4e95755f1659feae9763334eebbab044147fa3d94512dbb2a91360ec08728b

data/.github/workflows/rspec.yml

@@ -16,13 +16,28 @@ jobs:
         image: redislabs/redistimeseries:latest
         ports:
           - 6379:6379/tcp
+    env:
+      CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+      GIT_COMMIT_SHA: ${{ github.sha }}
+      GIT_BRANCH: ${{ github.head_ref }}
     steps:
     - uses: actions/checkout@v2
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: 2.6
+    - name: Set up CodeClimate
+      run: |
+        curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+        chmod +x ./cc-test-reporter
+        ./cc-test-reporter before-build
     - name: Install dependencies
       run: bundle install
     - name: Run specs
       run: bundle exec rake spec
+    - name: Upload coverage report
+      run: ./cc-test-reporter after-build -t simplecov coverage/.resultset.json
+    - uses: actions/upload-artifact@v2
+      with:
+        name: coverage
+        path: coverage/

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## Unreleased
 
+## 0.5.2
+* Add chunk_type to info struct (#47)
+
+## 0.5.1
+* Update Info struct for RTS 1.4 compatibility (#45)
+
+## 0.5.0
+* Fix aggregations for TS.RANGE command (#34)
+* Extract client handling into Client module (#32)
+* Add `uncompressed` param to TS.ADD, TS.INCRBY, TS.DECRBY (#35)
+* Add `Redis::TimeSeries::Rule` object (#38)
+* Add [YARD documentation](https://rubydoc.info/gems/redis-time-series) (#40)
+
+## 0.4.0
+* Added [hash-based filter DSL](https://github.com/dzunk/redis-time-series/tree/7173c73588da50614c02f9c89bf2ecef77766a78#filter-dsl)
+* Removed `Time#ts_msec` monkey-patch
+* Renamed `TimeSeries.queryindex` to `.query_index`
+* Added `TS.CREATERULE` and `TS.DELETERULE` commands
+* Renamed `InvalidFilters` to `FilterError`
+
+## 0.3.0
+* Added `TS.QUERYINDEX` command
+
 ## 0.2.0
 * Converted `#info` to a struct instead of a hash.
 * Added methods on time series for getting info attributes.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redis-time-series (0.1.1)
+    redis-time-series (0.5.2)
       redis (~> 4.0)
 
 GEM
@@ -16,15 +16,17 @@ GEM
     coderay (1.1.3)
     concurrent-ruby (1.1.6)
     diff-lcs (1.3)
+    docile (1.3.2)
     i18n (1.8.3)
       concurrent-ruby (~> 1.0)
+    json (2.3.1)
     method_source (1.0.0)
     minitest (5.14.1)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
     rake (13.0.1)
-    redis (4.2.1)
+    redis (4.2.2)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
@@ -38,6 +40,11 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.3)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
     thread_safe (0.3.6)
     tzinfo (1.2.7)
       thread_safe (~> 0.1)
@@ -53,6 +60,7 @@ DEPENDENCIES
   rake (~> 13.0)
   redis-time-series!
   rspec (~> 3.0)
+  simplecov (< 0.18)
 
 BUNDLED WITH
    1.17.2

data/README.md

@@ -1,4 +1,8 @@
-![](https://github.com/dzunk/redis-time-series/workflows/RSpec/badge.svg)
+[![RSpec](https://github.com/dzunk/redis-time-series/workflows/RSpec/badge.svg)](https://github.com/dzunk/redis-time-series/actions?query=workflow%3ARSpec+branch%3Amaster)
+[![Gem Version](https://badge.fury.io/rb/redis-time-series.svg)](https://badge.fury.io/rb/redis-time-series)
+[![Documentation](https://img.shields.io/badge/docs-rubydoc.info-brightgreen)](https://rubydoc.info/gems/redis-time-series)
+[![Maintainability](https://api.codeclimate.com/v1/badges/19a5925c20318508b4a4/maintainability)](https://codeclimate.com/github/dzunk/redis-time-series/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/19a5925c20318508b4a4/test_coverage)](https://codeclimate.com/github/dzunk/redis-time-series/test_coverage)
 
 # RedisTimeSeries
 
@@ -72,6 +76,10 @@ Add a single value with a timestamp
 ```ruby
 ts.add 1234, 3.minutes.ago # Used ActiveSupport here, but any Time object works fine
 => #<Redis::TimeSeries::Sample:0x00007fa6ce05f3f8 @time=2020-06-25 23:39:54 -0700, @value=0.1234e4>
+
+# Optionally store data uncompressed
+ts.add 5678, uncompressed: true
+=> #<Redis::TimeSeries::Sample:0x00007f93f43cdf68 @time=2020-07-18 23:15:29 -0700, @value=0.5678e4>
 ```
 Add multiple values with timestamps
 ```ruby
@@ -88,6 +96,10 @@ ts.increment # alias of incrby
 => 1593154255069
 ts.decrement # alias of decrby
 => 1593154257344
+
+# Optionally store data uncompressed
+ts.incrby 4, uncompressed: true
+=> 1595139299769
 ```
 ```ruby
 ts.get
@@ -119,31 +131,53 @@ ts.get
 ```
 Get a range of values
 ```ruby
-ts.range 10.minutes.ago..Time.current # Time range as an argument
+# Time range as an argument
+ts.range(10.minutes.ago..Time.current)
 => [#<Redis::TimeSeries::Sample:0x00007fa25f13fc28 @time=2020-06-25 23:50:51 -0700, @value=0.57e2>,
- #<Redis::TimeSeries::Sample:0x00007fa25f13db58 @time=2020-06-25 23:50:55 -0700, @value=0.58e2>,
- #<Redis::TimeSeries::Sample:0x00007fa25f13d900 @time=2020-06-25 23:50:57 -0700, @value=0.57e2>,
- #<Redis::TimeSeries::Sample:0x00007fa25f13d680 @time=2020-06-25 23:51:30 -0700, @value=0.58e2>]
-ts.range from: 10.minutes.ago, to: Time.current # Time range as keyword args
+    #<Redis::TimeSeries::Sample:0x00007fa25f13db58 @time=2020-06-25 23:50:55 -0700, @value=0.58e2>,
+    #<Redis::TimeSeries::Sample:0x00007fa25f13d900 @time=2020-06-25 23:50:57 -0700, @value=0.57e2>,
+    #<Redis::TimeSeries::Sample:0x00007fa25f13d680 @time=2020-06-25 23:51:30 -0700, @value=0.58e2>]
+
+# Time range as keyword args
+ts.range(from: 10.minutes.ago, to: Time.current)
 => [#<Redis::TimeSeries::Sample:0x00007fa25dc01f00 @time=2020-06-25 23:50:51 -0700, @value=0.57e2>,
- #<Redis::TimeSeries::Sample:0x00007fa25dc01d20 @time=2020-06-25 23:50:55 -0700, @value=0.58e2>,
- #<Redis::TimeSeries::Sample:0x00007fa25dc01b68 @time=2020-06-25 23:50:57 -0700, @value=0.57e2>,
- #<Redis::TimeSeries::Sample:0x00007fa25dc019b0 @time=2020-06-25 23:51:30 -0700, @value=0.58e2>]
+    #<Redis::TimeSeries::Sample:0x00007fa25dc01d20 @time=2020-06-25 23:50:55 -0700, @value=0.58e2>,
+    #<Redis::TimeSeries::Sample:0x00007fa25dc01b68 @time=2020-06-25 23:50:57 -0700, @value=0.57e2>,
+    #<Redis::TimeSeries::Sample:0x00007fa25dc019b0 @time=2020-06-25 23:51:30 -0700, @value=0.58e2>]
+
+# Limit number of results with count argument
+ts.range(10.minutes.ago..Time.current, count: 2)
+=> [#<Redis::TimeSeries::Sample:0x00007fa25dc01f00 @time=2020-06-25 23:50:51 -0700, @value=0.57e2>,
+    #<Redis::TimeSeries::Sample:0x00007fa25dc01d20 @time=2020-06-25 23:50:55 -0700, @value=0.58e2>]
+
+# Apply aggregations to the range
+ts.range(from: 10.minutes.ago, to: Time.current, aggregation: [:avg, 10.minutes])
+=> [#<Redis::TimeSeries::Sample:0x00007fa25dc01f00 @time=2020-06-25 23:50:00 -0700, @value=0.575e2>]
 ```
 Get info about the series
 ```ruby
 ts.info
 => #<struct Redis::TimeSeries::Info
+ series=
+  #<Redis::TimeSeries:0x00007ff46da9b578 @key="ts3", @redis=#<Redis client v4.2.1 for redis://127.0.0.1:6379/0>>,
  total_samples=3,
- memory_usage=4184,
- first_timestamp=1594060993011,
- last_timestamp=1594060993060,
+ memory_usage=4264,
+ first_timestamp=1595187993605,
+ last_timestamp=1595187993629,
  retention_time=0,
  chunk_count=1,
  max_samples_per_chunk=256,
  labels={"foo"=>"bar"},
  source_key=nil,
- rules=[]>
+ rules=
+  [#<Redis::TimeSeries::Rule:0x00007ff46db30c68
+    @aggregation=#<Redis::TimeSeries::Aggregation:0x00007ff46db30c18 @duration=3600000, @type="avg">,
+    @destination_key="ts1",
+    @source=
+     #<Redis::TimeSeries:0x00007ff46da9b578
+      @key="ts3",
+      @redis=#<Redis client v4.2.1 for redis://127.0.0.1:6379/0>>>]>
+
 # Each info property is also a method on the time series object
 ts.memory_usage
 => 4208
@@ -151,6 +185,7 @@ ts.labels
 => {"foo"=>"bar"}
 ts.total_samples
 => 3
+
 # Total samples also available as #count, #length, and #size
 ts.count
 => 3
@@ -159,36 +194,140 @@ ts.length
 ts.size
 => 3
 ```
+Find series matching specific label(s)
+```ruby
+Redis::TimeSeries.query_index('foo=bar')
+=> [#<Redis::TimeSeries:0x00007fc115ba1610
+  @key="ts3",
+  @redis=#<Redis client v4.2.1 for redis://127.0.0.1:6379/0>,
+  @retention=nil,
+  @uncompressed=false>]
+# Note that you need at least one "label equals value" filter
+Redis::TimeSeries.query_index('foo!=bar')
+=> RuntimeError: Filtering requires at least one equality comparison
+# query_index is also aliased as .where for fluency
+Redis::TimeSeries.where('foo=bar')
+=> [#<Redis::TimeSeries:0x00007fb8981010c8
+  @key="ts3",
+  @redis=#<Redis client v4.2.1 for redis://127.0.0.1:6379/0>,
+  @retention=nil,
+  @uncompressed=false>]
+```
+### Filter DSL
+You can provide filter strings directly, per the time series documentation.
+```ruby
+Redis::TimeSeries.where('foo=bar')
+=> [#<Redis::TimeSeries:0x00007fb8981010c8...>]
+```
+There is also a hash-based syntax available, which may be more pleasant to work with.
+```ruby
+Redis::TimeSeries.where(foo: 'bar')
+=> [#<Redis::TimeSeries:0x00007fb89811dca0...>]
+```
+All six filter types are represented in hash format below.
+```ruby
+{
+  foo: 'bar',          # label=value  (equality)
+  foo: { not: 'bar' }, # label!=value (inequality)
+  foo: true,           # label=       (presence)
+  foo: false,          # label!=      (absence)
+  foo: [1, 2],         # label=(1,2)  (any value)
+  foo: { not: [1, 2] } # label!=(1,2) (no values)
+}
+```
+Note the special use of `true` and `false`. If you're representing a boolean value with a label, rather than setting its value to "true" or "false" (which would be treated as strings in Redis anyway), you should add or remove the label from the series.
+
+Values can be any object that responds to `.to_s`:
+```ruby
+class Person
+  def initialize(name)
+    @name = name
+  end
+
+  def to_s
+    @name
+  end
+end
+
+Redis::TimeSeries.where(person: Person.new('John'))
+#=> TS.QUERYINDEX person=John
+```
+
+### Compaction Rules
+Add a compaction rule to a series.
+```ruby
+# Destintation time series needs to be created before the rule is added.
+other_ts = Redis::TimeSeries.create('other_ts')
+
+# Aggregation buckets are measured in milliseconds
+ts.create_rule(dest: other_ts, aggregation: [:count, 60000]) # 1 minute
+
+# Can provide a string key instead of a time series object
+ts.create_rule(dest: 'other_ts', aggregation: [:avg, 120000])
+
+# If you're using Rails or ActiveSupport, you can provide an
+# ActiveSupport::Duration instead of an integer
+ts.create_rule(dest: other_ts, aggregation: [:avg, 2.minutes])
+
+# Can also provide an Aggregation object instead of an array
+agg = Redis::TimeSeries::Aggregation.new(:avg, 120000)
+ts.create_rule(dest: other_ts, aggregation: agg)
+
+# Class-level method also available
+Redis::TimeSeries.create_rule(source: ts, dest: other_ts, aggregation: ['std.p', 150000])
+```
+Get existing compaction rules
+```ruby
+ts.rules
+=> [#<Redis::TimeSeries::Rule:0x00007ff46e91c728
+  @aggregation=#<Redis::TimeSeries::Aggregation:0x00007ff46e91c6d8 @duration=3600000, @type="avg">,
+  @destination_key="ts1",
+  @source=
+   #<Redis::TimeSeries:0x00007ff46da9b578 @key="ts3", @redis=#<Redis client v4.2.1 for redis://127.0.0.1:6379/0>>>]
+
+# Get properties of a rule too
+ts.rules.first.aggregation
+=> #<Redis::TimeSeries::Aggregation:0x00007ff46d146d38 @duration=3600000, @type="avg">
+ts.rules.first.destination
+=> #<Redis::TimeSeries:0x00007ff46d8a3d60 @key="ts1", @redis=#<Redis client v4.2.1 for redis://127.0.0.1:6379/0>>
+```
+
+Remove an existing compaction rule
+```ruby
+ts.delete_rule(dest: 'other_ts')
+ts.rules.first.delete
+Redis::TimeSeries.delete_rule(source: ts, dest: 'other_ts')
+```
+
 
 ### TODO
 * `TS.REVRANGE`
 * `TS.MRANGE`/`TS.MREVRANGE`
-* `TS.QUERYINDEX`
-* Compaction rules
-* Filters
 * Probably a bunch more stuff
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup`. You need the `docker` daemon installed and running. This script will:
+* Install gem dependencies
+* Pull the latest `redislabs/redistimeseries` image
+* Start a Redis server on port 6379
+* Seed three time series with some sample data
+* Attach to the running server and print logs to `STDOUT`
 
-In order to run the specs or use the console, you'll need a Redis server running on the default port 6379 with the RedisTimeSeries module enabled. The easiest way to do so is by running the Docker image:
-```
-docker run -p 6379:6379 -it --rm redislabs/redistimeseries
-```
-
-The `bin/console` script will set up three time series, `@ts1`, `@ts2`, and `@ts3`, with three values in each. **It will also flush the local Redis server each time you run it**, so don't try it if you have data you don't want to lose!
+With the above script running, or after starting a server manually, you can run `bin/console` to interact with it. The three series are named `ts1`, `ts2`, and `ts3`, and are available as instance variables in the console.
 
 If you want to see the commands being executed, run the console with `DEBUG=true bin/console` and it will output the raw command strings as they're executed.
 ```ruby
 [1] pry(main)> @ts1.increment
-DEBUG: TS.INCRBY foo 1
+DEBUG: TS.INCRBY ts1 1
 => 1593159795467
 [2] pry(main)> @ts1.get
-DEBUG: TS.GET foo
+DEBUG: TS.GET ts1
 => #<Redis::TimeSeries::Sample:0x00007f8e1a190cf8 @time=2020-06-26 01:23:15 -0700, @value=0.4e1>
 ```
 
+Use `rake spec` to run the test suite.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/dzunk/redis-time-series.

data/bin/console

@@ -6,15 +6,9 @@ require 'pry'
 require 'redis'
 require 'redis-time-series'
 
-Redis.current.flushall
-
-@ts1 = Redis::TimeSeries.create('foo')
-@ts2 = Redis::TimeSeries.create('bar')
-@ts3 = Redis::TimeSeries.create('baz')
-
+@ts1 = Redis::TimeSeries.new('ts1')
+@ts2 = Redis::TimeSeries.new('ts2')
+@ts3 = Redis::TimeSeries.new('ts3')
 @series = [@ts1, @ts2, @ts3]
-@series.each do |ts|
-  3.times { ts.increment; sleep 0.01 }
-end
 
 Pry.start

data/bin/setup

@@ -1,8 +1,31 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
+#!/usr/bin/env ruby
 
-bundle install
+system 'bundle install'
+system 'docker pull redislabs/redistimeseries:latest'
+container_id = `docker run -p 6379:6379 -dit --rm redislabs/redistimeseries`
+at_exit { system "docker stop #{container_id}" }
 
-# Do any other automated setup that you need to do here
+require 'bundler/setup'
+require 'active_support/core_ext/numeric/time'
+require 'redis'
+require 'redis-time-series'
+
+Redis.current.flushall
+ts1 = Redis::TimeSeries.create('ts1')
+ts2 = Redis::TimeSeries.create('ts2')
+ts3 = Redis::TimeSeries.create('ts3')
+
+ts1.add 12, 6.minutes.ago
+ts1.add 34, 4.minutes.ago
+ts1.add 56, 2.minutes.ago
+
+10.times { ts2.increment; sleep 0.01 }
+
+ts3.labels = { foo: 'bar' }
+ts3.add 1
+sleep 0.01
+ts3.incrby 2
+sleep 0.01
+ts3.decrement
+
+system "docker logs -f #{container_id}"

data/lib/ext/time_msec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# The +TimeMsec+ module is a refinement for the +Time+ class that makes it easier
+# to work with millisecond timestamps.
+#
+# @example
+#   Time.now.to_i    # 1595194259
+#   Time.now.ts_msec # NoMethodError
+#
+#   using TimeMsec
+#
+#   Time.now.to_i    # 1595194259
+#   Time.now.ts_msec # 1595194259000
+#
+#   Time.from_msec(1595194259000) # 2020-07-19 14:30:59 -0700
+module TimeMsec
+  refine Time do
+    # TODO: convert to #to_msec
+    def ts_msec
+      (to_f * 1000.0).to_i
+    end
+  end
+
+  refine Time.singleton_class do
+    def from_msec(timestamp)
+      at(timestamp / 1000.0)
+    end
+  end
+end