redis-objects-daily-counter 0.2.0 → 0.4.1

data/README.md

@@ -1,27 +1,28 @@
-[![CircleCI](https://circleci.com/gh/ryz310/redis-objects-daily-counter.svg?style=svg)](https://circleci.com/gh/ryz310/redis-objects-daily-counter) [![Gem Version](https://badge.fury.io/rb/redis-objects-daily-counter.svg)](https://badge.fury.io/rb/redis-objects-daily-counter) [![Maintainability](https://api.codeclimate.com/v1/badges/3639d1776e23031b1b31/maintainability)](https://codeclimate.com/github/ryz310/redis-objects-daily-counter/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/3639d1776e23031b1b31/test_coverage)](https://codeclimate.com/github/ryz310/redis-objects-daily-counter/test_coverage) [![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=ryz310/redis-objects-daily-counter)](https://dependabot.com)
+[![CircleCI](https://circleci.com/gh/ryz310/redis-objects-periodical.svg?style=svg)](https://circleci.com/gh/ryz310/redis-objects-periodical) [![Gem Version](https://badge.fury.io/rb/redis-objects-periodical.svg)](https://badge.fury.io/rb/redis-objects-periodical) [![Maintainability](https://api.codeclimate.com/v1/badges/deebb6c406c306a6f337/maintainability)](https://codeclimate.com/github/ryz310/redis-objects-periodical/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/deebb6c406c306a6f337/test_coverage)](https://codeclimate.com/github/ryz310/redis-objects-periodical/test_coverage)
 
-# Redis::Objects::Daily::Counter
+# Redis::Objects::Periodical
 
-This is a gem which extends [Redis::Objects](https://github.com/nateware/redis-objects) gem. Once install this gem, you can use the daily counter, etc. in addition to the standard features of Redis::Objects. These counters are useful for measuring conversions, implementing API rate limiting, and more.
+This is a gem which extends [Redis::Objects](https://github.com/nateware/redis-objects) gem. Once install this gem, you can use the periodical counter, the periodical set, etc. in addition to the standard features of Redis::Objects. These counters and sets are useful for measuring conversions, implementing API rate limiting, MAU, DAU, and more.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'redis-objects-daily-counter'
+gem 'redis-objects-periodical'
 ```
 
 If you want to know about installation and standard usage, please see Redis::Objects' GitHub page.
 
 ## Usage
 
-`daily_counter` automatically creates keys that are unique to each object, in the format:
+`daily_counter` and `daily_set` automatically creates keys that are unique to each object, in the format:
 
 ```
 model_name:id:field_name:yyyy-mm-dd
 ```
 
+I recommend using with `expireat` option.
 For illustration purposes, consider this stub class:
 
 ```rb
@@ -29,6 +30,8 @@ class Homepage
   include Redis::Objects
 
   daily_counter :pv, expireat: -> { Time.now + 2_678_400 } # about a month
+  daily_hash_key :browsing_history, expireat: -> { Time.now + 2_678_400 } # about a month
+  daily_set :dau, expireat: -> { Time.now + 2_678_400 } # about a month
 
   def id
     1
@@ -55,7 +58,9 @@ end_date = Date.new(2021, 4, 2)
 homepage.pv.range(start_date, end_date) # [3, 2]
 ```
 
-The daily counter automatically switches the save destination when the date changes.
+### Periodical Counters
+
+The periodical counters automatically switches the save destination when the date changes.
 You can access past dates counted values like Ruby arrays:
 
 ```rb
@@ -72,28 +77,123 @@ homepage.pv[Date.new(2021, 4, 1)] # => 3
 homepage.pv[Date.new(2021, 4, 1), 3] # => [3, 2, 5]
 homepage.pv[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => [3, 2]
 
-homepage.pv.delete(Date.new(2021, 4, 1))
+homepage.pv.delete_at(Date.new(2021, 4, 1))
 homepage.pv.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => [0, 2, 5]
-homepage.pv.at(Date.new(2021, 4, 2)) # => 2
+homepage.pv.at(Date.new(2021, 4, 2)) # => #<Redis::Counter key="homepage:1:pv:2021-04-02">
+homepage.pv.at(Date.new(2021, 4, 2)).value # 2
 ```
 
-### Counters
+#### Periodical Counters Family
 
-I recommend using with `expireat` option.
+- `annual_counter`
+  - Key format: `model_name:id:field_name:yyyy`
+  - Redis is a highly volatile key-value store, so I don't recommend using it.
+- `monthly_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm`
+- `weekly_counter`
+  - Key format: `model_name:id:field_name:yyyyWw`
+- `daily_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm-dd`
+- `hourly_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh`
+- `minutely_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh:mi`
+
+### Periodical Hashes
+
+The periodical hashes also automatically switches the save destination when the date changes.
+
+```rb
+# 2021-04-01
+homepage.browsing_history.incr('item1')
+homepage.browsing_history.incr('item2')
+homepage.browsing_history.incr('item2')
+puts homepage.browsing_history.all # { 'item1' => '1', 'item2' => '2' }
+
+# 2021-04-02 (next day)
+puts homepage.browsing_history.all # {}
+
+homepage.browsing_history.bulk_set('item1' => 3, 'item3' => 5)
+puts homepage.browsing_history.all # { 'item1' => '3', 'item3' => '5' }
+
+# 2021-04-03 (next day)
+homepage.browsing_history.incr('item2')
+homepage.browsing_history.incr('item4')
+puts homepage.browsing_history.all # { 'item2' => '1', 'item4' => '1' }
+
+homepage.browsing_history[Date.new(2021, 4, 1)] # => { 'item1' => '1', 'item2' => '2' }
+homepage.browsing_history[Date.new(2021, 4, 1), 3] # => { 'item1' => '4', 'item2' => '3', 'item3' => '5', 'item4' => '1' }
+homepage.browsing_history[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => { 'item1' => '4', 'item2' => '2', 'item3' => '5' }
+
+homepage.browsing_history.delete_at(Date.new(2021, 4, 1))
+homepage.browsing_history.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => { 'item1' => '3', 'item2' => '1', 'item3' => '5', 'item4' => '1' }
+homepage.browsing_history.at(Date.new(2021, 4, 2)) # => #<Redis::HashKey key="homepage:1:browsing_history:2021-04-02">
+homepage.browsing_history.at(Date.new(2021, 4, 2)).all # { 'item1' => '3', 'item3' => '5' }
+```
+
+#### Periodical Hashes Family
+
+- `annual_hash_key`
+  - Key format: `model_name:id:field_name:yyyy`
+  - Redis is a highly volatile key-value store, so I don't recommend using it.
+- `monthly_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm`
+- `weekly_hash_key`
+  - Key format: `model_name:id:field_name:yyyyWw`
+- `daily_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm-dd`
+- `hourly_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh`
+- `minutely_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh:mi`
+
+### Periodical Sets
+
+The periodical sets also automatically switches the save destination when the date changes.
+
+```rb
+# 2021-04-01
+homepage.dau << 'user1'
+homepage.dau << 'user2'
+homepage.dau << 'user1' # dup ignored
+puts homepage.dau.members # ['user1', 'user2']
+puts homepage.dau.length # 2
+puts homepage.dau.count # alias of #length
+
+# 2021-04-02 (next day)
+puts homepage.dau.members # []
+
+homepage.dau.merge('user2', 'user3')
+puts homepage.dau.members # ['user2', 'user3']
+
+# 2021-04-03 (next day)
+homepage.dau.merge('user4')
+
+homepage.dau[Date.new(2021, 4, 1)] # => ['user1', 'user2']
+homepage.dau[Date.new(2021, 4, 1), 3] # => ['user1', 'user2', 'user3', 'user4']
+homepage.dau[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => ['user1', 'user2', 'user3']
+
+homepage.dau.delete_at(Date.new(2021, 4, 1))
+homepage.dau.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => ['user2', 'user3', 'user4']
+homepage.dau.at(Date.new(2021, 4, 2)) # => #<Redis::Set key="homepage:1:dau:2021-04-02">
+homepage.dau.at(Date.new(2021, 4, 2)).members # ['user2', 'user3']
+```
 
-* `annual_counter`
-    * Key format: `model_name:id:field_name:yyyy`
-    * Redis is a highly volatile key-value store, so I don't recommend using it.
-* `monthly_counter`
-    * Key format: `model_name:id:field_name:yyyy-mm`
-* `weekly_counter`
-    * Key format: `model_name:id:field_name:yyyyWw`
-* `daily_counter`
-    * Key format: `model_name:id:field_name:yyyy-mm-dd`
-* `hourly_counter`
-    * Key format: `model_name:id:field_name:yyyy-mm-ddThh`
-* `minutely_counter`
-    * Key format: `model_name:id:field_name:yyyy-mm-ddThh:mi`
+#### Periodical Sets Family
+
+- `annual_set`
+  - Key format: `model_name:id:field_name:yyyy`
+  - Redis is a highly volatile key-value store, so I don't recommend using it.
+- `monthly_set`
+  - Key format: `model_name:id:field_name:yyyy-mm`
+- `weekly_set`
+  - Key format: `model_name:id:field_name:yyyyWw`
+- `daily_set`
+  - Key format: `model_name:id:field_name:yyyy-mm-dd`
+- `hourly_set`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh`
+- `minutely_set`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh:mi`
 
 ### Timezone
 
@@ -111,7 +211,7 @@ Please use the following command:
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/redis-objects-daily-counter. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/redis-objects-daily-counter/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/redis-objects-periodical. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/redis-objects-periodical/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -119,4 +219,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Redis::Objects::Daily::Counter project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/redis-objects-daily-counter/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Redis::Objects::Daily::Counter project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/redis-objects-periodical/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require 'bundler/gem_tasks'
+require 'bundler/gem_helper'
+
+Bundler::GemHelper.install_tasks(name: 'redis-objects-daily-counter')
+
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)

data/bin/console

@@ -2,10 +2,9 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'redis-objects-daily-counter'
+require 'redis-objects-periodical'
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+Redis::Objects.redis = Redis.new(host: 'redis', port: 6379)
 
 # (If you use this, don't forget to add pry to your Gemfile!)
 # require "pry"

data/lib/redis/base_counter_object.rb

@@ -1,54 +1,27 @@
 # frozen_string_literal: true
 
 class Redis
-  class BaseCounterObject < Counter
-    def initialize(key, *args)
-      @original_key = key
-      super(redis_daily_field_key(current_time), *args)
-    end
-
-    attr_reader :original_key
+  module BaseCounterObject
+    private
 
-    def [](date_or_time, length = nil)
-      if date_or_time.is_a? Range
-        range(date_or_time.first, date_or_time.max)
-      elsif length
-        case length <=> 0
-        when 1  then range(date_or_time, next_key(date_or_time, length))
-        when 0  then []
-        when -1 then nil  # Ruby does this (a bit weird)
-        end
-      else
-        at(date_or_time)
-      end
+    def get_redis_object(key)
+      Redis::Counter.new(key)
     end
-    alias slice []
 
-    def delete(date_or_time)
-      redis.del(redis_daily_field_key(date_or_time))
+    def get_value_from_redis(key)
+      redis.get(key).to_i
     end
 
-    def range(start_date, end_date)
-      keys = (start_date..end_date).map { |date| redis_daily_field_key(date) }.uniq
+    def get_values_from_redis(keys)
       redis.mget(*keys).map(&:to_i)
     end
 
-    def at(date_or_time)
-      redis.get(redis_daily_field_key(date_or_time)).to_i
-    end
-
-    def current_time
-      @current_time ||= Time.respond_to?(:current) ? Time.current : Time.now
-    end
-
-    private
-
-    def redis_daily_field_key(_date_or_time)
-      raise 'not implemented'
+    def delete_from_redis(key)
+      redis.del(key)
     end
 
-    def next_key(_date, _length)
-      raise 'not implemented'
+    def empty_value
+      []
     end
   end
 end

data/lib/redis/base_hash_key_object.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Redis
+  module BaseHashKeyObject
+    private
+
+    def get_redis_object(key)
+      Redis::HashKey.new(key)
+    end
+
+    def get_value_from_redis(key)
+      h = redis.hgetall(key) || {}
+      h.each { |k, v| h[k] = unmarshal(v, options[:marshal_keys][k]) }
+      h
+    end
+
+    def get_values_from_redis(keys) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      keys.inject({}) do |memo, key|
+        memo.merge(get_value_from_redis(key)) do |_, self_val, other_val|
+          values = [self_val, other_val]
+          if values.all? { |val| val =~ /\A\d+\z/ }
+            values.sum(&:to_i).to_s
+          elsif values.all? { |val| val =~ /\A\d+(\.\d+)?\z/ }
+            values.sum(&:to_f).to_s
+          else
+            values.join(',')
+          end
+        end
+      end
+    end
+
+    def delete_from_redis(key)
+      redis.del(key)
+    end
+
+    def empty_value
+      {}
+    end
+  end
+end

data/lib/redis/base_set_object.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Redis
+  module BaseSetObject
+    private
+
+    def get_redis_object(key)
+      Redis::Set.new(key)
+    end
+
+    def get_value_from_redis(key)
+      vals = redis.smembers(key)
+      vals.nil? ? [] : vals.map { |v| unmarshal(v) }
+    end
+
+    def get_values_from_redis(keys)
+      redis.sunion(*keys).map { |v| unmarshal(v) }
+    end
+
+    def delete_from_redis(key)
+      redis.del(key)
+    end
+
+    def empty_value
+      []
+    end
+  end
+end

data/lib/redis/objects/{daily-counter → periodical}/version.rb

@@ -2,10 +2,8 @@
 
 class Redis
   module Objects
-    module Daily
-      module Counter
-        VERSION = '0.2.0'
-      end
+    module Periodical
+      VERSION = '0.4.1'
     end
   end
 end

data/lib/redis/objects/periodical_counters.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'redis/periodical_counter'
+
+Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
+  new_module = Module.new
+  new_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def #{periodical}_counter(name, options = {})
+        options[:start] ||= 0
+        options[:type]  ||= (options[:start]).zero? ? :increment : :decrement
+        redis_objects[name.to_sym] = options.merge(type: :counter)
+
+        mod = Module.new do
+          define_method(name) do
+            Redis::#{periodical.capitalize}Counter.new(
+              redis_field_key(name), redis_field_redis(name), redis_options(name)
+            )
+          end
+        end
+
+        if options[:global]
+          extend mod
+
+          # dispatch to class methods
+          define_method(name) do
+            self.class.public_send(name)
+          end
+        else
+          include mod
+        end
+      end
+    end
+  RUBY
+  Redis::Objects.const_set("#{periodical.capitalize}Counters", new_module)
+end

data/lib/redis/objects/periodical_hashes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'redis/periodical_hash_key'
+
+Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
+  new_module = Module.new
+  new_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    # Class methods that appear in your class when you include Redis::Objects.
+    module ClassMethods
+      # Define a new hash key.  It will function like a regular instance
+      # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+      def #{periodical}_hash_key(name, options = {})
+        redis_objects[name.to_sym] = options.merge(type: :dict)
+
+        mod = Module.new do
+          define_method(name) do
+            Redis::#{periodical.capitalize}HashKey.new(
+              redis_field_key(name), redis_field_redis(name), redis_options(name)
+            )
+          end
+
+          define_method(:"#\{name\}=") do |values|
+            hash_key = public_send(name)
+
+            redis.pipelined do
+              hash_key.clear
+              hash_key.bulk_set(values)
+            end
+          end
+        end
+
+        if options[:global]
+          extend mod
+
+          # dispatch to class methods
+          define_method(name) do
+            self.class.public_send(name)
+          end
+        else
+          include mod
+        end
+      end
+    end
+  RUBY
+  Redis::Objects.const_set("#{periodical.capitalize}Hashes", new_module)
+end

data/lib/redis/objects/periodical_sets.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'redis/periodical_set'
+
+Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
+  new_module = Module.new
+  new_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    # Class methods that appear in your class when you include Redis::Objects.
+    module ClassMethods
+      # Define a new list.  It will function like a regular instance
+      # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+      def #{periodical}_set(name, options = {})
+        redis_objects[name.to_sym] = options.merge(type: :set)
+
+        mod = Module.new do
+          define_method(name) do
+            Redis::#{periodical.capitalize}Set.new(
+              redis_field_key(name), redis_field_redis(name), redis_options(name)
+            )
+          end
+
+          define_method(:"#\{name\}=") do |values|
+            set = public_send(name)
+
+            redis.pipelined do
+              set.clear
+              set.merge(*values)
+            end
+          end
+        end
+
+        if options[:global]
+          extend mod
+
+          # dispatch to class methods
+          define_method(name) do
+            self.class.public_send(name)
+          end
+        else
+          include mod
+        end
+      end
+    end
+  RUBY
+  Redis::Objects.const_set("#{periodical.capitalize}Sets", new_module)
+end

data/lib/redis/periodical_counter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/recurring_at_intervals"
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+Redis::PERIODICALS.each do |periodical|
+  require "#{File.dirname(__FILE__)}/recurring_at_intervals/#{periodical}"
+
+  new_class = Class.new(Redis::Counter) do
+    include Redis::RecurringAtIntervals
+    include Redis::BaseCounterObject
+    include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
+  end
+  Redis.const_set("#{periodical.capitalize}Counter", new_class)
+end

data/lib/redis/periodical_hash_key.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/recurring_at_intervals"
+require "#{File.dirname(__FILE__)}/base_hash_key_object"
+
+Redis::PERIODICALS.each do |periodical|
+  require "#{File.dirname(__FILE__)}/recurring_at_intervals/#{periodical}"
+
+  new_class = Class.new(Redis::HashKey) do
+    include Redis::RecurringAtIntervals
+    include Redis::BaseHashKeyObject
+    include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
+  end
+  Redis.const_set("#{periodical.capitalize}HashKey", new_class)
+end

data/lib/redis/periodical_set.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/recurring_at_intervals"
+require "#{File.dirname(__FILE__)}/base_set_object"
+
+Redis::PERIODICALS.each do |periodical|
+  require "#{File.dirname(__FILE__)}/recurring_at_intervals/#{periodical}"
+
+  new_class = Class.new(Redis::Set) do
+    include Redis::RecurringAtIntervals
+    include Redis::BaseSetObject
+    include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
+  end
+  Redis.const_set("#{periodical.capitalize}Set", new_class)
+end

data/lib/redis/recurring_at_intervals/annual.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Annual
+      private
+
+      def redis_daily_field_key(date_or_time)
+        date_key = date_or_time.strftime('%Y')
+        [original_key, date_key].flatten.join(':')
+      end
+
+      def next_key(date, length = 1)
+        date.next_year(length)
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/daily.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Daily
+      private
+
+      def redis_daily_field_key(date_or_time)
+        date_key = date_or_time.strftime('%Y-%m-%d')
+        [original_key, date_key].flatten.join(':')
+      end
+
+      def next_key(date, length = 1)
+        date + length
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/hourly.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Hourly
+      private
+
+      def redis_daily_field_key(time)
+        time_key = time.strftime('%Y-%m-%dT%H')
+        [original_key, time_key].flatten.join(':')
+      end
+
+      def next_key(time, length = 1)
+        time + 3600 * length
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/minutely.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Minutely
+      private
+
+      def redis_daily_field_key(time)
+        time_key = time.strftime('%Y-%m-%dT%H:%M')
+        [original_key, time_key].flatten.join(':')
+      end
+
+      def next_key(time, length = 1)
+        time + 60 * length
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/monthly.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Monthly
+      private
+
+      def redis_daily_field_key(date_or_time)
+        date_key = date_or_time.strftime('%Y-%m')
+        [original_key, date_key].flatten.join(':')
+      end
+
+      def next_key(date, length = 1)
+        date.next_month(length)
+      end
+    end
+  end
+end