redis-time-series 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60ddc8ba631c4016031490a9eb8c3e8659d6b38d3f21e3798a253ec3f63b2815
-  data.tar.gz: 7993209c75f9f23ed0fae6f918020f2a7a793575e6636e57c1bc225db3f3a63d
+  metadata.gz: 400fac8affe8b6c5acbc7892bd9704fb39da3135929451ce282ad43278f698ff
+  data.tar.gz: 70a10d9ca8cd01e8b113e6b769008ccb0e9a167cbd16777773d2df8d8a41d2c2
 SHA512:
-  metadata.gz: 1bd033ed2dfef155ba923ebee94089e41f507dcb8fcb63711a56585703d1603c32ff86b99067641b8a248587925d2bf489affd79822118e5fb42b05dbcf1c374
-  data.tar.gz: 553ffbea629efff4b1b436faf7542f35204cd9a0f47c2cf28dcd3ecc0261bd399eb19ac57a56985fc3fbeaef0e4b2e24786483bc385e06928fedcbad4f6709d0
+  metadata.gz: 7b166b6d74161936686e1f0d8d6d5b27238414036b16fc8c4537cc02a2848734b8bf26a183820069b7ad662d45465fc38e6fc1c307dbc543c028a746a30d5024
+  data.tar.gz: 3f3f178d267e261e9c3ee17b50fff7e5826d231bf9051364c070727af13841a6118596c255857bf750973445a9860cbbeaa007001425f602d409381dd24a851f

data/.github/workflows/rspec.yml

@@ -11,9 +11,14 @@ on:
 jobs:
   spec:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        image_version: ['latest', 'edge']
+        ruby_version: ['2.6', '2.7', '3.0', '3.1']
     services:
       redis:
-        image: redislabs/redistimeseries:latest
+        image: redislabs/redistimeseries:${{ matrix.image_version }}
         ports:
           - 6379:6379/tcp
     env:
@@ -25,16 +30,18 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.6
+        ruby-version: ${{ matrix.ruby_version }}
     - 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
+      run: |
+        bundle install
+        bundle exec appraisal install
     - name: Run specs
-      run: bundle exec rake spec
+      run: bundle exec appraisal rake spec
     - name: Upload coverage report
       run: ./cc-test-reporter after-build -t simplecov coverage/.resultset.json
     - uses: actions/upload-artifact@v2

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+Gemfile.lock
 
 # rspec failure tracking
 .rspec_status

data/Appraisals

@@ -0,0 +1,7 @@
+appraise 'redis 3' do
+  gem 'redis', '~> 3.3'
+end
+
+appraise 'redis 4' do
+  gem 'redis', '~> 4.0'
+end

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## Unreleased
 
+## 0.7.0
+* Add Ruby 3.1 to build matrix (#70)
+* Add Ruby 3.0 to build matrix (#63)
+* Relax Redis version constraint (#62)
+* Add TS.REVRANGE, TS.MRANGE, and TS.MREVRANGE commands (#19)
+* Update TS.MADD commands to consolidate parsing (#58)
+
+## 0.6.0
+* Add CHUNK_SIZE param to CREATE, ADD, INCRBY, DECRBY commands (#53)
+* Add duplication policy to TS.CREATE and TS.ADD commands (#51)
+* Add support for endless ranges to TS.RANGE (#50)
+* Cast label values to integers in Info struct (#49)
+* Build against edge upstream in addition to latest stable (#48)
+
+## 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)

data/README.md

@@ -24,7 +24,7 @@ ts.add 56
 => #<Redis::TimeSeries::Sample:0x00007f8c0d26c460 @time=2020-06-25 23:23:16 -0700, @value=0.56e2>
 ts.add 78
 => #<Redis::TimeSeries::Sample:0x00007f8c0d276618 @time=2020-06-25 23:23:20 -0700, @value=0.78e2>
-ts.range (Time.now.to_i - 100)..Time.now.to_i
+ts.range (Time.now.to_i - 100)..Time.now.to_i * 1000
 => [#<Redis::TimeSeries::Sample:0x00007f8c0d297200 @time=2020-06-25 23:23:04 -0700, @value=0.1234e4>,
  #<Redis::TimeSeries::Sample:0x00007f8c0d297048 @time=2020-06-25 23:23:16 -0700, @value=0.56e2>,
  #<Redis::TimeSeries::Sample:0x00007f8c0d296e90 @time=2020-06-25 23:23:20 -0700, @value=0.78e2>]
@@ -213,6 +213,38 @@ Redis::TimeSeries.where('foo=bar')
   @retention=nil,
   @uncompressed=false>]
 ```
+
+### Querying Multiple Series
+Get all samples from matching series over a time range with `mrange`
+```ruby
+[4] pry(main)> result = Redis::TimeSeries.mrange(1.minute.ago.., filter: { foo: 'bar' })
+=> [#<struct Redis::TimeSeries::Multi::Result
+  series=
+   #<Redis::TimeSeries:0x00007f833e408ad0
+    @key="ts3",
+    @redis=#<Redis client v4.2.5 for redis://127.0.0.1:6379/0>>,
+  labels=[],
+  samples=
+   [#<Redis::TimeSeries::Sample:0x00007f833e408a58
+     @time=2021-06-17 20:58:33 3246391/4194304 -0700,
+     @value=0.1e1>,
+    #<Redis::TimeSeries::Sample:0x00007f833e408850
+     @time=2021-06-17 20:58:33 413139/524288 -0700,
+     @value=0.3e1>,
+    #<Redis::TimeSeries::Sample:0x00007f833e408670
+     @time=2021-06-17 20:58:33 1679819/2097152 -0700,
+     @value=0.2e1>]>]
+[5] pry(main)> result.keys
+=> ["ts3"]
+[6] pry(main)> result['ts3'].values
+=> [0.1e1, 0.3e1, 0.2e1]
+```
+Order them from newest to oldest with `mrevrange`
+```ruby
+[8] pry(main)> Redis::TimeSeries.mrevrange(1.minute.ago.., filter: { foo: 'bar' }).first.values
+=> [0.2e1, 0.3e1, 0.1e1]
+```
+
 ### Filter DSL
 You can provide filter strings directly, per the time series documentation.
 ```ruby
@@ -299,11 +331,8 @@ ts.rules.first.delete
 Redis::TimeSeries.delete_rule(source: ts, dest: 'other_ts')
 ```
 
-
 ### TODO
-* `TS.REVRANGE`
-* `TS.MRANGE`/`TS.MREVRANGE`
-* Probably a bunch more stuff
+* Check the [open issues](https://github.com/dzunk/redis-time-series/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc) on Github.
 
 ## Development
 

data/lib/redis/time_series/duplicate_policy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+class Redis
+  class TimeSeries
+    # Duplication policies can be applied to a time series in order to resolve conflicts
+    # when adding data that already exists in the series.
+    #
+    # @see https://oss.redislabs.com/redistimeseries/master/configuration/#duplicate_policy
+    class DuplicatePolicy
+      VALID_POLICIES = %i[
+        block
+        first
+        last
+        min
+        max
+        sum
+      ].freeze
+
+      attr_reader :policy
+
+      def initialize(policy)
+        policy = policy.to_s.downcase.to_sym
+        if VALID_POLICIES.include?(policy)
+          @policy = policy
+        else
+          raise UnknownPolicyError, "#{policy} is not a valid duplicate policy"
+        end
+      end
+
+      def to_a(cmd = 'DUPLICATE_POLICY')
+        [cmd, policy]
+      end
+
+      def to_s(cmd = 'DUPLICATE_POLICY')
+        to_a(cmd).join(' ')
+      end
+
+      def ==(other)
+        return policy == other.policy if other.is_a?(self.class)
+        policy == self.class.new(other).policy
+      end
+
+      VALID_POLICIES.each do |policy|
+        define_method("#{policy}?") do
+          @policy == policy
+        end
+      end
+    end
+  end
+end

data/lib/redis/time_series/errors.rb

@@ -15,5 +15,10 @@ class Redis
     # an unknown type, or when calling a command with an invalid aggregation value.
     # @see Redis::TimeSeries::Aggregation
     class AggregationError < Error; end
+
+    # +UnknownPolicyError+ is raised when attempting to apply an unkown type of
+    # duplicate policy when creating or adding to a series.
+    # @see Redis::TimeSeries::DuplicatePolicy
+    class UnknownPolicyError < Error; end
   end
 end

data/lib/redis/time_series/info.rb

@@ -10,6 +10,10 @@ class Redis
     #
     # @!attribute [r] chunk_count
     #   @return [Integer] number of memory chunks used for the time-series
+    # @!attribute [r] chunk_size
+    #   @return [Integer] amount of allocated memory in bytes
+    # @!attribute [r] chunk_type
+    #   @return [String] whether the chunk is "compressed" or "uncompressed"
     # @!attribute [r] first_timestamp
     #   @return [Integer] first timestamp present in the time-series (milliseconds since epoch)
     # @!attribute [r] labels
@@ -37,6 +41,9 @@ class Redis
     # @see https://oss.redislabs.com/redistimeseries/commands/#tsinfo
     Info = Struct.new(
       :chunk_count,
+      :chunk_size,
+      :chunk_type,
+      :duplicate_policy,
       :first_timestamp,
       :labels,
       :last_timestamp,
@@ -49,18 +56,43 @@ class Redis
       :total_samples,
       keyword_init: true
     ) do
-      # @api private
-      # @return [Info]
-      def self.parse(series:, data:)
-        data.each_slice(2).reduce({}) do |h, (key, value)|
-          # Convert camelCase info keys to snake_case
-          h[key.gsub(/(.)([A-Z])/,'\1_\2').downcase] = value
-          h
-        end.then do |parsed_hash|
-          parsed_hash['series'] = series
-          parsed_hash['labels'] = parsed_hash['labels'].to_h
-          parsed_hash['rules'] = parsed_hash['rules'].map { |d| Rule.new(source: series, data: d) }
-          new(parsed_hash)
+      class << self
+        # @api private
+        # @return [Info]
+        def parse(series:, data:)
+          build_hash(data)
+            .merge(series: series)
+            .then(&method(:parse_labels))
+            .then(&method(:parse_policies))
+            .then(&method(:parse_rules))
+            .then(&method(:new))
+        end
+
+        private
+
+        def build_hash(data)
+          data.each_slice(2).reduce({}) do |h, (key, value)|
+            # Convert camelCase info keys to snake_case
+            key = key.gsub(/(.)([A-Z])/,'\1_\2').downcase.to_sym
+            # Skip unknown properties
+            next h unless members.include?(key)
+            h.merge(key => value)
+          end
+        end
+
+        def parse_labels(hash)
+          hash[:labels] = hash[:labels].to_h.transform_values { |v| v.to_i.to_s == v ? v.to_i : v }
+          hash
+        end
+
+        def parse_policies(hash)
+          hash[:duplicate_policy] = DuplicatePolicy.new(hash[:duplicate_policy]) if hash[:duplicate_policy]
+          hash
+        end
+
+        def parse_rules(hash)
+          hash[:rules] = hash[:rules].map { |d| Rule.new(source: hash[:series], data: d) }
+          hash
         end
       end
 

data/lib/redis/time_series/multi.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+class Redis
+  class TimeSeries
+    # A {Multi} is a collection of multiple series and their samples, returned
+    # from a multi command (e.g. TS.MGET or TS.MRANGE).
+    #
+    # @see TimeSeries.mrange
+    # @see TimeSeries.mrevrange
+    class Multi < DelegateClass(Array)
+      # Multis are initialized by one of the class-level query commands.
+      # There's no need to ever create one yourself.
+      # @api private
+      def initialize(result_array)
+        super(result_array.map do |res|
+          Result.new(
+            TimeSeries.new(res[0]),
+            res[1],
+            res[2].map { |s| Sample.new(s[0], s[1]) }
+          )
+        end)
+      end
+
+      # Access a specific result by either array position, or hash lookup.
+      #
+      # @param index_or_key [Integer, String] The integer position, or series
+      #   key, of the specific result to return.
+      # @return [Multi::Result, nil] A single series result, or nil if there is
+      #   no matching series.
+      def [](index_or_key)
+        return super if index_or_key.is_a?(Integer)
+        find { |result| result.series.key == index_or_key.to_s }
+      end
+
+      # Get all the series keys that are present in this result collection.
+      # @return [Array<String>] An array of the series keys in these results.
+      def keys
+        map { |r| r.series.key }
+      end
+
+      # Get all the series objects that are present in this result collection.
+      # @return [Array<TimeSeries>] An array of the series in these results.
+      def series
+        map(&:series)
+      end
+
+      # Convert these results into a hash, keyed by series name.
+      # @return [Hash<Array>] A hash of series names and samples.
+      # @example
+      #   {"ts3"=>
+      #     [{:timestamp=>1623945216042, :value=>0.1e1},
+      #      {:timestamp=>1623945216055, :value=>0.3e1},
+      #      {:timestamp=>1623945216069, :value=>0.2e1}]}
+      def to_h
+        super do |result|
+          [result.series.key, result.samples.map(&:to_h)]
+        end
+      end
+
+      # Get a count of all matching samples from all series in this result collection.
+      # @return [Integer] The total size of all samples from all series in these results.
+      def sample_count
+        reduce(0) { |size, r| size += r.samples.size }
+      end
+
+      Result = Struct.new(:series, :labels, :samples) do
+        def values
+          samples.map(&:value)
+        end
+      end
+    end
+  end
+end

data/lib/redis/time_series/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 class Redis
   class TimeSeries
-    VERSION = '0.5.0'
+    VERSION = '0.7.0'
   end
 end

data/lib/redis/time_series.rb

@@ -37,6 +37,12 @@ class Redis
       #   With no value, the series will not be trimmed.
       # @option options [Boolean] :uncompressed
       #   When true, series data will be stored in an uncompressed format.
+      # @option options [String, Symbol] :duplicate_policy
+      #   A duplication policy to resolve conflicts when adding values to the series.
+      #   Valid values are in Redis::TimeSeries::DuplicatePolicy::VALID_POLICIES
+      # @option options [Integer] :chunk_size
+      #   Amount of memory, in bytes, to allocate for each chunk of data. Must be a multiple
+      #   of 8. Default for a series is 4096.
       #
       # @return [Redis::TimeSeries] the created time series
       # @see https://oss.redislabs.com/redistimeseries/commands/#tscreate
@@ -83,6 +89,23 @@ class Redis
         redis.del key
       end
 
+      # Add multiple values to multiple series.
+      #
+      # @example Adding multiple values with timestamps
+      #   Redis::TimeSeries.madd(
+      #     foo: { 2.minutes.ago => 123, 1.minute.ago => 456, Time.current => 789) },
+      #     bar: { 2.minutes.ago => 987, 1.minute.ago => 654, Time.current => 321) }
+      #   )
+      # @example Adding multiple values without timestamps
+      #   Redis::TimeSeries.madd(foo: 1, bar: 2, baz: 3)
+      #
+      # @param data [Hash] A hash of key-value pairs, with the key being the name of
+      #   the series, and the value being a single scalar value or a nested hash
+      #   of timestamp => value pairs
+      # @return [Array<Sample, Redis::CommandError>] an array of the resulting samples
+      #   added, or a CommandError if the sample in question could not be added to the
+      #   series
+      #
       def madd(data)
         data.reduce([]) do |memo, (key, value)|
           memo << parse_madd_values(key, value)
@@ -93,6 +116,46 @@ class Redis
           end
         end
       end
+      alias multi_add madd
+      alias add_multiple madd
+
+      # Query across multiple series, returning values from oldest to newest.
+      #
+      # @param range [Range] A time range over which to query. Beginless and endless ranges
+      #   indicate oldest and most recent timestamp, respectively.
+      # @param filter [Hash, String] a set of filters to query with. Refer to the {Filters}
+      #   documentation for more details on how to filter.
+      # @param count [Integer] The maximum number of results to return for each series.
+      # @param aggregation [Array(<String, Symbol>, Integer), Aggregation]
+      #   The aggregation to apply. Can be an {Aggregation} object, or an array of
+      #   aggregation_type and duration +[:avg, 120000]+
+      # @param with_labels [Boolean] Whether to return the label details of the matched
+      #   series in the result object.
+      # @return [Multi] A multi-series collection of results
+      #
+      # @see https://oss.redislabs.com/redistimeseries/commands/#tsmrangetsmrevrange
+      def mrange(range, filter:, count: nil, aggregation: nil, with_labels: false)
+        multi_cmd('TS.MRANGE', range, filter, count, aggregation, with_labels)
+      end
+
+      # Query across multiple series, returning values from newest to oldest.
+      #
+      # @param range [Range] A time range over which to query. Beginless and endless ranges
+      #   indicate oldest and most recent timestamp, respectively.
+      # @param filter [Hash, String] a set of filters to query with. Refer to the {Filters}
+      #   documentation for more details on how to filter.
+      # @param count [Integer] The maximum number of results to return for each series.
+      # @param aggregation [Array(<String, Symbol>, Integer), Aggregation]
+      #   The aggregation to apply. Can be an {Aggregation} object, or an array of
+      #   aggregation_type and duration +[:avg, 120000]+
+      # @param with_labels [Boolean] Whether to return the label details of the matched
+      #   series in the result object.
+      # @return [Multi] A multi-series collection of results
+      #
+      # @see https://oss.redislabs.com/redistimeseries/commands/#tsmrangetsmrevrange
+      def mrevrange(range, filter:, count: nil, aggregation: nil, with_labels: false)
+        multi_cmd('TS.MREVRANGE', range, filter, count, aggregation, with_labels)
+      end
 
       # Search for a time series matching the provided filters. Refer to the {Filters} documentation
       # for more details on how to filter.
@@ -119,19 +182,36 @@ class Redis
 
       private
 
+      def multi_cmd(cmd_name, range, filter, count, agg, with_labels)
+        filters = Filters.new(filter)
+        filters.validate!
+        cmd(
+          cmd_name,
+          (range.begin || '-'),
+          (range.end || '+'),
+          (['COUNT', count] if count),
+          Aggregation.parse(agg)&.to_a,
+          ('WITHLABELS' if with_labels),
+          ['FILTER', filters.to_a]
+        ).then { |response| Multi.new(response) }
+      end
+
       def key_for(series_or_string)
         series_or_string.is_a?(self) ? series_or_string.key : series_or_string.to_s
       end
 
       def parse_madd_values(key, raw)
-        if raw.is_a?(Hash) || (raw.is_a?(Array) && raw.first.is_a?(Array))
+        if raw.is_a? Hash
           # multiple timestamp => value pairs
           raw.map do |timestamp, value|
             [key, timestamp, value]
           end
         elsif raw.is_a? Array
-          # single [timestamp, value]
-          [key, raw.first, raw.last]
+          # multiple values, no timestamps
+          now = Time.now.ts_msec
+          raw.each_with_index.map do |value, index|
+            [key, now + index, value]
+          end
         else
           # single value, no timestamp
           [key, '*', raw]
@@ -154,21 +234,33 @@ class Redis
     # @param value [Numeric] the value to add
     # @param timestamp [Time, Numeric] the +Time+, or integer timestamp in milliseconds, to add the value
     # @param uncompressed [Boolean] if true, stores data in an uncompressed format
+    # @param on_duplicate [String, Symbol] a duplication policy for conflict resolution
+    # @param chunk_size [Integer] set default chunk size, in bytes, for the time series
     #
     # @return [Sample] the value that was added
     # @raise [Redis::CommandError] if the value being added is older than the latest timestamp in the series
-    def add(value, timestamp = '*', uncompressed: nil)
-      ts = cmd 'TS.ADD', key, timestamp, value, ('UNCOMPRESSED' if uncompressed)
+    #
+    # @see TimeSeries::DuplicatePolicy
+    def add(value, timestamp = '*', uncompressed: nil, on_duplicate: nil, chunk_size: nil)
+      ts = cmd 'TS.ADD',
+               key,
+               timestamp,
+               value,
+               ('UNCOMPRESSED' if uncompressed),
+               (['CHUNK_SIZE', chunk_size] if chunk_size),
+               (DuplicatePolicy.new(on_duplicate).to_a('ON_DUPLICATE') if on_duplicate)
       Sample.new(ts, value)
     end
 
     # Issues a TS.CREATE command for the current series.
     # You should use class method {Redis::TimeSeries.create} instead.
     # @api private
-    def create(retention: nil, uncompressed: nil, labels: nil)
+    def create(retention: nil, uncompressed: nil, labels: nil, duplicate_policy: nil, chunk_size: nil)
       cmd 'TS.CREATE', key,
           (['RETENTION', retention] if retention),
           ('UNCOMPRESSED' if uncompressed),
+          (['CHUNK_SIZE', chunk_size] if chunk_size),
+          (DuplicatePolicy.new(duplicate_policy).to_a if duplicate_policy),
           (['LABELS', labels.to_a] if labels&.any?)
       self
     end
@@ -206,11 +298,17 @@ class Redis
     # @param value [Integer] the amount to decrement by
     # @param timestamp [Time, Integer] the Time or integer millisecond timestamp to save the new value at
     # @param uncompressed [Boolean] if true, stores data in an uncompressed format
+    # @param chunk_size [Integer] set default chunk size, in bytes, for the time series
     #
     # @return [Integer] the timestamp the value was stored at
     # @see https://oss.redislabs.com/redistimeseries/commands/#tsincrbytsdecrby
-    def decrby(value = 1, timestamp = nil, uncompressed: nil)
-      cmd 'TS.DECRBY', key, value, (timestamp if timestamp), ('UNCOMPRESSED' if uncompressed)
+    def decrby(value = 1, timestamp = nil, uncompressed: nil, chunk_size: nil)
+      cmd 'TS.DECRBY',
+          key,
+          value,
+          (timestamp if timestamp),
+          ('UNCOMPRESSED' if uncompressed),
+          (['CHUNK_SIZE', chunk_size] if chunk_size)
     end
     alias decrement decrby
 
@@ -241,11 +339,17 @@ class Redis
     # @param value [Integer] the amount to increment by
     # @param timestamp [Time, Integer] the Time or integer millisecond timestamp to save the new value at
     # @param uncompressed [Boolean] if true, stores data in an uncompressed format
+    # @param chunk_size [Integer] set default chunk size, in bytes, for the time series
     #
     # @return [Integer] the timestamp the value was stored at
     # @see https://oss.redislabs.com/redistimeseries/commands/#tsincrbytsdecrby
-    def incrby(value = 1, timestamp = nil, uncompressed: nil)
-      cmd 'TS.INCRBY', key, value, (timestamp if timestamp), ('UNCOMPRESSED' if uncompressed)
+    def incrby(value = 1, timestamp = nil, uncompressed: nil, chunk_size: nil)
+      cmd 'TS.INCRBY',
+          key,
+          value,
+          (timestamp if timestamp),
+          ('UNCOMPRESSED' if uncompressed),
+          (['CHUNK_SIZE', chunk_size] if chunk_size)
     end
     alias increment incrby
 
@@ -272,32 +376,30 @@ class Redis
       cmd 'TS.ALTER', key, 'LABELS', val.to_a
     end
 
-    def madd(*values)
-      if values.one? && values.first.is_a?(Hash)
-        # Hash of timestamp => value pairs
-        args = values.first.map do |ts, val|
-          [key, ts, val]
-        end.flatten
-      elsif values.one? && values.first.is_a?(Array)
-        # Array of values, no timestamps
-        initial_ts = Time.now.ts_msec
-        args = values.first.each_with_index.map do |val, idx|
-          [key, initial_ts + idx, val]
-        end.flatten
-      else
-        # Values as individual arguments, no timestamps
-        initial_ts = Time.now.ts_msec
-        args = values.each_with_index.map do |val, idx|
-          [key, initial_ts + idx, val]
-        end.flatten
+    # Add multiple values to the series.
+    #
+    # @example Adding multiple values with timestamps
+    #   ts.madd(2.minutes.ago => 987, 1.minute.ago => 654, Time.current => 321)
+    #
+    # @param data [Hash] A hash of key-value pairs, with the key being a Time
+    #   object or integer timestamp, and the value being a single scalar value
+    # @return [Array<Sample, Redis::CommandError>] an array of the resulting samples
+    #   added, or a CommandError if the sample in question could not be added to the
+    #   series
+    #
+    def madd(data)
+      args = self.class.send(:parse_madd_values, key, data)
+      cmd('TS.MADD', args).each_with_index.map do |result, idx|
+        result.is_a?(Redis::CommandError) ? result : Sample.new(result, args[idx][2])
       end
-      # TODO: return Sample objects here
-      cmd 'TS.MADD', args
     end
+    alias multi_add madd
+    alias add_multiple madd
 
-    # Get a range of values from the series
+    # Get a range of values from the series, from earliest to most recent
     #
-    # @param range [Hash, Range] a time range, or hash of +from+ and +to+ values
+    # @param range [Range] A time range over which to query. Beginless and endless ranges
+    #   indicate oldest and most recent timestamp, respectively.
     # @param count [Integer] the maximum number of results to return
     # @param aggregation [Array(<String, Symbol>, Integer), Aggregation]
     #   The aggregation to apply. Can be an {Aggregation} object, or an array of
@@ -307,20 +409,23 @@ class Redis
     #
     # @see https://oss.redislabs.com/redistimeseries/commands/#tsrangetsrevrange
     def range(range, count: nil, aggregation: nil)
-      if range.is_a?(Hash)
-        # This is to support from: and to: passed in as hash keys
-        # `range` will swallow all parameters if they're all hash syntax
-        count = range.delete(:count)
-        aggregation = range.delete(:aggregation)
-        range = range.fetch(:from)..range.fetch(:to)
-      end
-      cmd('TS.RANGE',
-          key,
-          range.min,
-          range.max,
-          (['COUNT', count] if count),
-          Aggregation.parse(aggregation)&.to_a
-         ).map { |ts, val| Sample.new(ts, val) }
+      range_cmd('TS.RANGE', range, count, aggregation)
+    end
+
+    # Get a range of values from the series, from most recent to earliest
+    #
+    # @param range [Range] A time range over which to query. Beginless and endless ranges
+    #   indicate oldest and most recent timestamp, respectively.
+    # @param count [Integer] the maximum number of results to return
+    # @param aggregation [Array(<String, Symbol>, Integer), Aggregation]
+    #   The aggregation to apply. Can be an {Aggregation} object, or an array of
+    #   aggregation_type and duration +[:avg, 120000]+
+    #
+    # @return [Array<Sample>] an array of samples matching the range query
+    #
+    # @see https://oss.redislabs.com/redistimeseries/commands/#tsrangetsrevrange
+    def revrange(range, count: nil, aggregation: nil)
+      range_cmd('TS.REVRANGE', range, count, aggregation)
     end
 
     # Set data retention time for the series using +TS.ALTER+
@@ -340,5 +445,17 @@ class Redis
       return false unless other.is_a?(self.class)
       key == other.key && redis == other.redis
     end
+
+    private
+
+    def range_cmd(cmd_name, range, count, agg)
+      cmd(cmd_name,
+          key,
+          (range.begin || '-'),
+          (range.end || '+'),
+          (['COUNT', count] if count),
+          Aggregation.parse(agg)&.to_a
+         ).map { |ts, val| Sample.new(ts, val) }
+    end
   end
 end

data/lib/redis-time-series.rb

@@ -1,10 +1,13 @@
 require 'bigdecimal'
 require 'forwardable'
 require 'ext/time_msec'
+
 require 'redis/time_series/client'
 require 'redis/time_series/errors'
 require 'redis/time_series/aggregation'
+require 'redis/time_series/duplicate_policy'
 require 'redis/time_series/filters'
+require 'redis/time_series/multi'
 require 'redis/time_series/rule'
 require 'redis/time_series/info'
 require 'redis/time_series/sample'

data/redis-time-series.gemspec

@@ -31,10 +31,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'redis', '~> 4.0'
+  spec.add_dependency 'redis', '>= 3.3'
 
   spec.add_development_dependency 'activesupport', '~> 6.0'
-  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'appraisal', '>= 2.4.1'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'pry', '~> 0.13'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: redis-time-series
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Matt Duszynski
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-20 00:00:00.000000000 Z
+date: 2022-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -38,20 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +122,7 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.18'
-description: 
+description:
 email:
 - dzunk@hey.com
 executables: []
@@ -118,9 +132,9 @@ files:
 - ".github/workflows/rspec.yml"
 - ".gitignore"
 - ".rspec"
+- Appraisals
 - CHANGELOG.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -131,9 +145,11 @@ files:
 - lib/redis/time_series.rb
 - lib/redis/time_series/aggregation.rb
 - lib/redis/time_series/client.rb
+- lib/redis/time_series/duplicate_policy.rb
 - lib/redis/time_series/errors.rb
 - lib/redis/time_series/filters.rb
 - lib/redis/time_series/info.rb
+- lib/redis/time_series/multi.rb
 - lib/redis/time_series/rule.rb
 - lib/redis/time_series/sample.rb
 - lib/redis/time_series/version.rb
@@ -145,7 +161,7 @@ metadata:
   homepage_uri: https://github.com/dzunk/redis-time-series
   source_code_uri: https://github.com/dzunk/redis-time-series
   changelog_uri: https://github.com/dzunk/redis-time-series/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -160,8 +176,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: A Ruby adapter for the RedisTimeSeries module.
 test_files: []

data/Gemfile.lock

@@ -1,66 +0,0 @@
-PATH
-  remote: .
-  specs:
-    redis-time-series (0.5.0)
-      redis (~> 4.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (6.0.3.1)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
-    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)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.2)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
-      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)
-    zeitwerk (2.3.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (~> 6.0)
-  bundler (~> 1.17)
-  pry (~> 0.13)
-  rake (~> 13.0)
-  redis-time-series!
-  rspec (~> 3.0)
-  simplecov (< 0.18)
-
-BUNDLED WITH
-   1.17.2