kredis 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9aa90994f3d30a19d52df3fbc284d43d2637e940de06f221ecffc2853eeda459
-  data.tar.gz: 713137c0ec2c28bfb80df9c94b3e61c4b8f5906c9d68631fd5e26e4ac8ef0771
+  metadata.gz: 678d0983bf3cb50abb7732dc3c3e4da93764173dbdf03ce367254dbdb9297ef2
+  data.tar.gz: 7209773f020b0d1055171f30f6ff204786f3edf84e5938cd09f55789fd86e934
 SHA512:
-  metadata.gz: afcbb020c7e7c412090a7798c433882adf7d54e293728eff3a7d39b655d41531a3bae5f307ea10faa72a39e6ed1cb1f7db1f3f6535351299d26f65fd20e728fb
-  data.tar.gz: 7de324aa868056600c28d82911ef654c7d9f58c5d85823ab1271a7518c76f9dbb31a2be23082cb9ab2bf210401eac0ceca698412a38f01779af310bcf5893624
+  metadata.gz: 2aa0b22042910eaa558f1bf8e5fed47aa7385d16ba46f63024f9311760a4f2ee74c42dadb3f333388755d1862a04999ca83cc016bf023a3e1a48491f089c7e03
+  data.tar.gz: ff37e6f461fc3117fd7d02116da43931550683581c6327a176f58d3f09ba06b2da538cd27976f01d7922a7ce7bf9768a8c03445b25e3dc62e635f3ac953093e0

data/README.md

@@ -2,48 +2,164 @@
 
 Kredis (Keyed Redis) encapsulates higher-level types and data structures around a single key, so you can interact with them as coherent objects rather than isolated procedural commands. These higher-level structures can be configured as attributes within Active Models and Active Records using a declarative DSL.
 
-Kredis is configured using env-aware yaml files, using `Rails.application.config_for`, so you can locate the data structures on separate redis instances, if you've reached a scale where a single shared instance is no longer sufficient.
+Kredis is configured using env-aware YAML files, using `Rails.application.config_for`, so you can locate the data structures on separate Redis instances, if you've reached a scale where a single shared instance is no longer sufficient.
 
 Kredis provides namespacing support for keys such that you can safely run parallel testing against the data structures without different tests trampling each others data.
 
 
 ## Examples
 
-Kredis provides typed scalars for strings, integers, decimals, floats, booleans, datetimes, and json hashes:
+Kredis provides typed scalars for strings, integers, decimals, floats, booleans, datetimes, and JSON hashes:
 
 ```ruby
 string = Kredis.string "mystring"
 string.value = "hello world!"  # => SET mystring "hello world"
 "hello world!" == string.value # => GET mystring
 
-integer = Kredis.string "myinteger"
+integer = Kredis.integer "myinteger"
 integer.value = 5  # => SET myinteger "5"
-5 == string.value # => GET myinteger
+5 == integer.value # => GET myinteger
+
+decimal = Kredis.decimal "mydecimal" # accuracy!
+decimal.value = "%.47f" % (1.0/10) # => SET mydecimal "0.10000000000000000555111512312578270211815834045"
+BigDecimal("0.10000000000000000555111512312578270211815834045e0") == decimal.value # => GET mydecimal
+
+float = Kredis.float "myfloat" # speed!
+float.value = 1.0/10 # => SET myfloat "0.1"
+0.1 == float.value # => GET myfloat
+
+boolean = Kredis.boolean "myboolean"
+boolean.value = true # => SET myboolean "t"
+true == boolean.value # => GET myboolean
+
+datetime = Kredis.datetime "mydatetime"
+memoized_midnight = Time.zone.now.midnight
+datetime.value = memoized_midnight # SET mydatetime "2021-07-27T00:00:00.000000000Z"
+memoized_midnight == datetime.value # => GET mydatetime
 
 json = Kredis.json "myjson"
-integer.value = { "one" => 1, "two" => "2" }  # => SET myjson "{\"one\":1,\"two\":\"2\"}"
-{ "one" => 1, "two" => "2" } == string.value  # => GET myjson
+json.value = { "one" => 1, "two" => "2" }  # => SET myjson "{\"one\":1,\"two\":\"2\"}"
+{ "one" => 1, "two" => "2" } == json.value  # => GET myjson
 ```
 
-There are data structures for counters, enums, flags, lists, uniqe lists, sets, and slots:
+There are data structures for counters, enums, flags, lists, unique lists, sets, and slots:
 
 ```ruby
-list = Kredis.list "mylist", typed: :integer
-list.append([ 1, 2, 3 ])        # => LPUSH mylist "1" "2" "3"
-list << 4                       # => LPUSH mylist "4"
-[ 1, 2, 3, 4 ] == list.elements # LRANGE 0 -1
+list = Kredis.list "mylist"
+list << "hello world!"               # => RPUSH mylist "hello world!"
+[ "hello world!" ] == list.elements  # => LRANGE mylist 0, -1
+
+integer_list = Kredis.list "myintegerlist", typed: :integer
+integer_list.append([ 1, 2, 3 ])        # => RPUSH myintegerlist "1" "2" "3"
+integer_list << 4                       # => RPUSH myintegerlist "4"
+[ 1, 2, 3, 4 ] == integer_list.elements # => LRANGE myintegerlist 0 -1
+
+unique_list = Kredis.unique_list "myuniquelist"
+unique_list.append(%w[ 2 3 4 ])                # => LREM myuniquelist 0, "2" + LREM myuniquelist 0, "3" + LREM myuniquelist 0, "4"  + RPUSH myuniquelist "2", "3", "4"
+unique_list.prepend(%w[ 1 2 3 4 ])             # => LREM myuniquelist 0, "1"  + LREM myuniquelist 0, "2" + LREM myuniquelist 0, "3" + LREM myuniquelist 0, "4"  + LPUSH myuniquelist "1", "2", "3", "4"
+unique_list.append([])
+unique_list << "5"                             # => LREM myuniquelist 0, "5" + RPUSH myuniquelist "5"
+unique_list.remove(3)                          # => LREM myuniquelist 0, "3"
+[ "4", "2", "1", "5" ] == unique_list.elements # => LRANGE myuniquelist 0, -1
 
 set = Kredis.set "myset", typed: :datetime
-set.add(DateTime.tomorrow, DateTime.yesterday)            # => SADD myset "2021-02-03 00:00:00 +0100" "2021-02-01 00:00:00 +0100"
-set << DateTime.tomorrow                                  # => SADD myset "2021-02-03 00:00:00 +0100"
-2 == set.size                                             # => SCARD myset
-[ DateTime.tomorrow, DateTime.yesterday ] == set.elements # => SMEMBERS myset
-
-counter = Kredis.counter "mycounter", expires_in: 15.minutes
-counter.increment by: 2         # => SETEX "mycounter" 900 0 + INCR "mycounter" 2
+set.add(DateTime.tomorrow, DateTime.yesterday)           # => SADD myset "2021-02-03 00:00:00 +0100" "2021-02-01 00:00:00 +0100"
+set << DateTime.tomorrow                                 # => SADD myset "2021-02-03 00:00:00 +0100"
+2 == set.size                                            # => SCARD myset
+[ DateTime.tomorrow, DateTime.yesterday ] == set.members # => SMEMBERS myset
+
+hash = Kredis.hash "myhash"
+hash.update("key" => "value", "key2" => "value2")     # => HSET myhash "key", "value", "key2", "value2"
+{ "key" => "value", "key2" => "value2" } == hash.to_h # => HGETALL myhash
+"value2" == hash["key2"]                              # => HMGET myhash "key2"
+%w[ key key2 ] == hash.keys                           # => HKEYS myhash
+%w[ value value2 ] == hash.values                     # => HVALS myhash
+hash.remove                                           # => DEL myhash
+
+high_scores = Kredis.hash "high_scores", typed: :integer
+high_scores.update(space_invaders: 100, pong: 42)             # HSET high_scores "space_invaders", "100", "pong", "42"
+%w[ space_invaders pong ] == high_scores.keys                 # HKEYS high_scores
+[ 100, 42 ] == high_scores.values                             # HVALS high_scores
+{ "space_invaders" => 100, "pong" => 42 } == high_scores.to_h # HGETALL high_scores
+
+head_count = Kredis.counter "headcount"
+0 == head_count.value              # => GET "headcount"
+head_count.increment               # => SET headcount 0 NX + INCRBY headcount 1
+head_count.increment               # => SET headcount 0 NX + INCRBY headcount 1
+head_count.decrement               # => SET headcount 0 NX + DECRBY headcount 1
+1 == head_count.value              # => GET "headcount"
+
+counter = Kredis.counter "mycounter", expires_in: 5.seconds
+counter.increment by: 2         # => SET mycounter 0 EX 5 NX + INCRBY "mycounter" 2
 2 == counter.value              # => GET "mycounter"
-travel 16.minutes
+sleep 6.seconds
 0 == counter.value              # => GET "mycounter"
+
+cycle = Kredis.cycle "mycycle", values: %i[ one two three ]
+:one == cycle.value             # => GET mycycle
+cycle.next                      # => GET mycycle + SET mycycle 1
+:two == cycle.value             # => GET mycycle
+cycle.next                      # => GET mycycle + SET mycycle 2
+:three == cycle.value           # => GET mycycle
+cycle.next                      # => GET mycycle + SET mycycle 0
+:one == cycle.value             # => GET mycycle
+
+enum = Kredis.enum "myenum", values: %w[ one two three ], default: "one"
+"one" == enum.value             # => GET myenum  
+true == enum.one?               # => GET myenum
+enum.value = "two"              # => SET myenum "two"
+"two" == enum.value             # => GET myenum
+enum.value = "four"
+"two" == enum.value             # => GET myenum
+enum.reset                      # => DEL myenum
+"one" == enum.value             # => GET myenum  
+
+slots = Kredis.slots "myslots", available: 3
+true == slots.available?        # => GET myslots
+slots.reserve                   # => INCR myslots
+true == slots.available?        # => GET myslots
+slots.reserve                   # => INCR myslots     
+true == slots.available?        # => GET myslots
+slots.reserve                   # => INCR myslots
+false == slots.available?       # => GET myslots
+slots.reserve                   # => INCR myslots + DECR myslots  
+false == slots.available?       # => GET myslots
+slots.release                   # => DECR myslots
+true == slots.available?        # => GET myslots
+slots.reset                     # => DEL myslots
+
+
+slot = Kredis.slot "myslot"
+true == slot.available?        # => GET myslot
+slot.reserve                   # => INCR myslot
+false == slot.available?       # => GET myslot
+slot.release                   # => DECR myslot
+true == slot.available?        # => GET myslot
+slot.reset                     # => DEL myslot
+
+flag = Kredis.flag "myflag"
+false == flag.marked?           # => EXISTS myflag
+flag.mark                       # => SET myflag 1
+true == flag.marked?            # => EXISTS myflag
+flag.remove                     # => DEL myflag  
+false == flag.marked?           # => EXISTS myflag
+
+flag.mark(expires_in: 1.second) #=> SET myflag 1 EX 1
+true == flag.marked?            #=> EXISTS myflag
+sleep 0.5.seconds
+true == flag.marked?            #=> EXISTS myflag
+sleep 0.6.seconds
+false == flag.marked?           #=> EXISTS myflag
+```
+
+And using structures on a different than the default `shared` redis instance, relying on `config/redis/secondary.yml`:
+
+```ruby
+one_string = Kredis.string "mystring"
+two_string = Kredis.string "mystring", config: :secondary
+
+one_string.value = "just on shared"
+two_string.value != one_string.value
 ```
 
 You can use all these structures in models:
@@ -57,12 +173,23 @@ class Person < ApplicationRecord
 end
 
 person = Person.find(5)
-person.names.append "David", "Heinemeier", "Hansson" # => SADD person:5:names "David" "Heinemeier" "Hansson"
-true == person.morning.bright?
-person.morning.value = "blue"
-true == person.morning.blue?
+person.names.append "David", "Heinemeier", "Hansson" # => RPUSH people:5:names "David" "Heinemeier" "Hansson"
+true == person.morning.bright?                       # => GET people:1:morning
+person.morning.value = "blue"                        # => SET people:1:morning
+true == person.morning.blue?                         # => GET people:1:morning
 ```
 
+You can also define `after_change` callbacks that trigger on mutations:
+
+```ruby
+class Person < ApplicationRecord
+  kredis_list :names, after_change: ->(p) {  }
+  kredis_unique_list :skills, limit: 2, after_change: :skillset_changed
+
+  def skillset_changed
+  end
+end
+```
 
 ## Installation
 
@@ -87,8 +214,34 @@ test:
   <<: *development
 ```
 
-Additional configurations can be added under `config/redis/*.yml` and referenced when a type is created.
+Additional configurations can be added under `config/redis/*.yml` and referenced when a type is created, e.g. `Kredis.string("mystring", config: :strings)` would lookup `config/redis/strings.yml`. Under the hood `Kredis.configured_for` is called which'll pass the configuration on to `Redis.new`.
+
+### Setting SSL options on Redis Connections
+
+If you need to connect to Redis with SSL, the recommended approach is to set your Redis instance manually by adding an entry to the `Kredis::Connections.connections` hash. Below an example showing how to connect to Redis using Client Authentication:
+
+```ruby
+Kredis::Connections.connections[:shared] = Redis.new(
+  url: ENV['REDIS_URL'],
+  ssl_params: {
+    cert_store: OpenSSL::X509::Store.new.tap { |store|
+      store.add_file(Rails.root.join('config', 'ca_cert.pem').to_s)
+    },
+
+    cert: OpenSSL::X509::Certificate.new(File.read(
+      Rails.root.join('config', 'client.crt')
+    )),
+
+    key: OpenSSL::PKey::RSA.new(
+      Rails.application.credentials.redis[:client_key]
+    ),
+
+    verify_mode: OpenSSL::SSL::VERIFY_PEER
+  }
+)
+```
 
+The above code could be added to either `config/environments/production.rb` or an initializer. Please ensure that your client private key, if used, is stored your credentials file or another secure location.
 
 ## License
 

data/lib/kredis/attributes.rb

@@ -2,68 +2,83 @@ module Kredis::Attributes
   extend ActiveSupport::Concern
 
   class_methods do
-    def kredis_proxy(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_proxy(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_string(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_string(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_integer(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_integer(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_datetime(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_decimal(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_flag(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_datetime(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
+    end
+
+    def kredis_flag(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
 
       define_method("#{name}?") do
         send(name).marked?
       end
     end
 
-    def kredis_enum(name, key: nil, values:, default:, config: :shared)
-      kredis_connection_with __method__, name, key, values: values, default: default, config: config
+    def kredis_enum(name, key: nil, values:, default:, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, values: values, default: default, config: config, after_change: after_change
+    end
+
+    def kredis_json(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
+    end
+
+    def kredis_list(name, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_json(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, limit: limit, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_list(name, key: nil, typed: :string, config: :shared)
-      kredis_connection_with __method__, name, key, typed: typed, config: config
+    def kredis_set(name, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared)
-      kredis_connection_with __method__, name, key, limit: limit, typed: typed, config: config
+    def kredis_slot(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_set(name, key: nil, typed: :string, config: :shared)
-      kredis_connection_with __method__, name, key, typed: typed, config: config
+    def kredis_slots(name, available:, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, available: available, config: config, after_change: after_change
     end
 
-    def kredis_slot(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_counter(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_slots(name, available:, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, available: available, config: config
+    def kredis_hash(name, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
     end
 
     private
       def kredis_connection_with(method, name, key, **options)
         ivar_symbol = :"@#{name}_#{method}"
         type = method.to_s.sub("kredis_", "")
+        after_change = options.delete(:after_change)
 
         define_method(name) do
           if instance_variable_defined?(ivar_symbol)
             instance_variable_get(ivar_symbol)
           else
-            instance_variable_set(ivar_symbol, Kredis.send(type, kredis_key_evaluated(key) || kredis_key_for_attribute(name), **options))
+            new_type = Kredis.send(type, kredis_key_evaluated(key) || kredis_key_for_attribute(name), **options)
+            instance_variable_set ivar_symbol,
+              after_change ? enrich_after_change_with_record_access(new_type, after_change) : new_type
           end
         end
       end
@@ -78,6 +93,17 @@ module Kredis::Attributes
     end
 
     def kredis_key_for_attribute(name)
-      "#{self.class.name.tableize.gsub("/", ":")}:#{id}:#{name}"
+      "#{self.class.name.tableize.gsub("/", ":")}:#{extract_kredis_id}:#{name}"
+    end
+
+    def extract_kredis_id
+      try(:id) or raise NotImplementedError, "kredis needs a unique id, either implement an id method or pass a custom key."
+    end
+
+    def enrich_after_change_with_record_access(type, original_after_change)
+      case original_after_change
+      when Proc   then Kredis::Types::CallbacksProxy.new(type, ->(_) { original_after_change.call(self) })
+      when Symbol then Kredis::Types::CallbacksProxy.new(type, ->(_) { send(original_after_change) })
+      end
     end
 end

data/lib/kredis/connections.rb

@@ -6,13 +6,22 @@ module Kredis::Connections
 
   def configured_for(name)
     connections[name] ||= begin
-      logger&.info "[Kredis] Connected to #{name}"
-      Redis.new configurator.config_for("redis/#{name}")
+      Kredis.instrument :meta, message: "Connected to #{name}" do
+        Redis.new configurator.config_for("redis/#{name}")
+      end
     end
   end
 
   def clear_all
-    logger&.info "[Kredis] Connections all cleared"
-    connections.each_value(&:flushdb)
+    Kredis.instrument :meta, message: "Connections all cleared" do
+      connections.each_value do |connection|
+        if Kredis.namespace
+          keys = connection.keys("#{Kredis.namespace}:*")
+          connection.del keys if keys.any?
+        else
+          connection.flushdb
+        end
+      end
+    end
   end
 end

data/lib/kredis/log_subscriber.rb

@@ -0,0 +1,22 @@
+require "active_support/log_subscriber"
+
+class Kredis::LogSubscriber < ActiveSupport::LogSubscriber
+  def proxy(event)
+    debug formatted_in(YELLOW, event, type: "Proxy")
+  end
+
+  def migration(event)
+    debug formatted_in(YELLOW, event, type: "Migration")
+  end
+
+  def meta(event)
+    info formatted_in(MAGENTA, event)
+  end
+
+  private
+    def formatted_in(color, event, type: nil)
+      color "  Kredis #{type} (#{event.duration.round(1)}ms)  #{event.payload[:message]}", color, true
+    end
+end
+
+Kredis::LogSubscriber.attach_to :kredis

data/lib/kredis/migration.rb

@@ -1,47 +1,53 @@
 require "active_support/core_ext/module/delegation"
 
 class Kredis::Migration
-  singleton_class.delegate :migrate_all, :migrate, to: :new
+  singleton_class.delegate :migrate_all, :migrate, :delete_all, to: :new
 
   def initialize(config = :shared)
     @redis = Kredis.configured_for config
+    # TODO: Replace script loading with `copy` command once Redis 6.2+ is the minimum supported version.
     @copy_sha = @redis.script "load", "redis.call('SETNX', KEYS[2], redis.call('GET', KEYS[1])); return 1;"
   end
 
   def migrate_all(key_pattern)
-    find_keys_in_batches_matching(key_pattern) do |keys|
-      @redis.multi do
-        keys.each do |key|
-          ids = key.scan(/\d+/).map(&:to_i)
-          migrate from: key, to: yield(key, *ids)
-        end
+    each_key_batch_matching(key_pattern) do |keys|
+      keys.each do |key|
+        ids = key.scan(/\d+/).map(&:to_i)
+        migrate from: key, to: yield(key, *ids)
       end
     end
   end
 
   def migrate(from:, to:)
-    to = Kredis.namespaced_key(to)
+    namespaced_to = Kredis.namespaced_key(to)
 
-    if from != to
-      log_migration "Migrating key #{from} to #{to}"
-      @redis.evalsha @copy_sha, keys: [ from, to ]
+    if to.present? && from != namespaced_to
+      log_migration "Migrating key #{from} to #{namespaced_to}" do
+        @redis.evalsha @copy_sha, keys: [ from, namespaced_to ]
+      end
     else
-      log_migration "Skipping unaltered migration key #{from}"
+      log_migration "Skipping blank/unaltered migration key #{from} → #{to}"
+    end
+  end
+
+  def delete_all(key_pattern)
+    each_key_batch_matching(key_pattern) do |keys|
+      @redis.del *keys
     end
   end
 
   private
     SCAN_BATCH_SIZE = 1_000
 
-    def find_keys_in_batches_matching(key_pattern, &block)
+    def each_key_batch_matching(key_pattern, &block)
       cursor = "0"
       begin
         cursor, keys = @redis.scan(cursor, match: key_pattern, count: SCAN_BATCH_SIZE)
-        yield keys
+        @redis.pipelined { yield keys }
       end until cursor == "0"
     end
 
-    def log_migration(message)
-      Kredis.logger&.debug "[Kredis Migration] #{message}"
+    def log_migration(message, &block)
+      Kredis.instrument :migration, message: message, &block
     end
 end

data/lib/kredis/railtie.rb

@@ -1,33 +1,29 @@
-require "rails/railtie"
+class Kredis::Railtie < ::Rails::Railtie
+  config.kredis = ActiveSupport::OrderedOptions.new
 
-module Kredis
-  class Railtie < ::Rails::Railtie
-    config.kredis = ActiveSupport::OrderedOptions.new
-
-    initializer "kredis.testing" do
-      ActiveSupport.on_load(:active_support_test_case) do
-        parallelize_setup    { |worker| Kredis.namespace = "test-#{worker}" }
-        parallelize_teardown { Kredis.clear_all }
-      end
+  initializer "kredis.testing" do
+    ActiveSupport.on_load(:active_support_test_case) do
+      parallelize_setup { |worker| Kredis.namespace = "test-#{worker}" }
+      teardown { Kredis.clear_all }
     end
+  end
 
-    initializer "kredis.logger" do
-      Kredis.logger = config.kredis.logger || Rails.logger
-    end
+  initializer "kredis.logger" do
+    Kredis::LogSubscriber.logger = config.kredis.logger || Rails.logger
+  end
 
-    initializer "kredis.configurator" do
-      Kredis.configurator = Rails.application
-    end
+  initializer "kredis.configurator" do
+    Kredis.configurator = Rails.application
+  end
 
-    initializer "kredis.attributes" do
-      # TODO: Add run_load_hooks to ActiveModel::Model so this runs.
-      ActiveSupport.on_load(:active_model) do
-        include Kredis::Attributes
-      end
+  initializer "kredis.attributes" do
+    # No load hook for Active Model, just defer until after initialization.
+    config.after_initialize do
+      ActiveModel::Model.include Kredis::Attributes if defined?(ActiveModel::Model)
+    end
 
-      ActiveSupport.on_load(:active_record) do
-        include Kredis::Attributes
-      end
+    ActiveSupport.on_load(:active_record) do
+      include Kredis::Attributes
     end
   end
 end

data/lib/kredis/type_casting.rb

@@ -1,3 +1,5 @@
+require "json"
+
 module Kredis::TypeCasting
   class InvalidType < StandardError; end
 
@@ -16,7 +18,7 @@ module Kredis::TypeCasting
     when TrueClass, FalseClass
       value ? "t" : "f"
     when Time, DateTime, ActiveSupport::TimeWithZone
-      value.to_f
+      value.iso8601(9)
     when Hash
       JSON.dump(value)
     else
@@ -25,7 +27,7 @@ module Kredis::TypeCasting
   end
 
   def string_to_type(value, type)
-    raise InvalidType if type && !type.in?(VALID_TYPES)
+    raise InvalidType if type && !VALID_TYPES.include?(type)
 
     case type
     when nil, :string then value
@@ -33,7 +35,7 @@ module Kredis::TypeCasting
     when :decimal     then value.to_d
     when :float       then value.to_f
     when :boolean     then value == "t" ? true : false
-    when :datetime    then Time.at(value.to_i)
+    when :datetime    then Time.iso8601(value)
     when :json        then JSON.load(value)
     end if value.present?
   end

data/lib/kredis/types/callbacks_proxy.rb

@@ -0,0 +1,31 @@
+class Kredis::Types::CallbacksProxy
+  attr_reader :type
+  delegate :to_s, to: :type
+
+  AFTER_CHANGE_OPERATIONS = {
+    Kredis::Types::Counter => %i[ increment decrement reset ],
+    Kredis::Types::Cycle => %i[ next ],
+    Kredis::Types::Enum => %i[ value= reset ],
+    Kredis::Types::Flag => %i[ mark remove ],
+    Kredis::Types::Hash => %i[ update delete ],
+    Kredis::Types::List => %i[ remove prepend append << ],
+    Kredis::Types::Scalar => %i[ value= clear ],
+    Kredis::Types::Set => %i[ add << remove replace take clear ],
+    Kredis::Types::Slots => %i[ reserve release reset ]
+  }
+
+  def initialize(type, callback)
+    @type, @callback = type, callback
+  end
+
+  def method_missing(method, *args, **kwargs, &block)
+    result = type.send(method, *args, **kwargs, &block)
+    invoke_suitable_after_change_callback_for method
+    result
+  end
+
+  private
+    def invoke_suitable_after_change_callback_for(method)
+      @callback.call(type) if AFTER_CHANGE_OPERATIONS[type.class]&.include? method
+    end
+end

data/lib/kredis/types/counter.rb

@@ -1,5 +1,5 @@
 class Kredis::Types::Counter < Kredis::Types::Proxying
-  proxying :multi, :set, :incrby, :get
+  proxying :multi, :set, :incrby, :decrby, :get, :del
 
   attr_accessor :expires_in
 
@@ -10,7 +10,18 @@ class Kredis::Types::Counter < Kredis::Types::Proxying
     end
   end
 
+  def decrement(by: 1)
+    multi do
+      set 0, ex: expires_in, nx: true
+      decrby by
+    end
+  end
+
   def value
     get.to_i
   end
+
+  def reset
+    del
+  end
 end

data/lib/kredis/types/cycle.rb

@@ -0,0 +1,13 @@
+class Kredis::Types::Cycle < Kredis::Types::Counter
+  attr_accessor :values
+
+  alias index value
+
+  def value
+    values[index]
+  end
+
+  def next
+    set (index + 1) % values.size
+  end
+end

data/lib/kredis/types/hash.rb

@@ -0,0 +1,45 @@
+require "active_support/core_ext/hash"
+
+class Kredis::Types::Hash < Kredis::Types::Proxying
+  proxying :hget, :hset, :hmget, :hdel, :hgetall, :hkeys, :hvals, :del
+
+  attr_accessor :typed
+
+  def [](key)
+    string_to_type(hget(key), typed)
+  end
+
+  def []=(key, value)
+    update key => value
+  end
+
+
+  def update(**entries)
+    hset types_to_strings(entries) if entries.flatten.any?
+  end
+
+  def values_at(*keys)
+    strings_to_types(hmget(keys) || [], typed)
+  end
+
+  def delete(*keys)
+    hdel types_to_strings(keys) if keys.flatten.any?
+  end
+
+  def remove
+    del 
+  end
+
+  def entries
+    (hgetall || {}).transform_values { |val| string_to_type(val, typed) }.with_indifferent_access
+  end
+  alias to_h entries
+
+  def keys
+    hkeys || []
+  end
+
+  def values
+    strings_to_types(hvals || [], typed)
+  end
+end

data/lib/kredis/types/proxy/failsafe.rb

@@ -0,0 +1,26 @@
+module Kredis::Types::Proxy::Failsafe
+  def initialize(*)
+    super
+    @fail_safe_suppressed = false
+  end
+
+  def failsafe
+    yield
+  rescue Redis::BaseError
+    raise if fail_safe_suppressed?
+  end
+
+  def suppress_failsafe_with(returning: nil)
+    old_fail_safe_suppressed, @fail_safe_suppressed = @fail_safe_suppressed, true
+    yield
+  rescue Redis::BaseError
+    returning
+  ensure
+    @fail_safe_suppressed = old_fail_safe_suppressed
+  end
+
+  private
+    def fail_safe_suppressed?
+      @fail_safe_suppressed
+    end
+end

data/lib/kredis/types/proxy.rb

@@ -1,4 +1,7 @@
 class Kredis::Types::Proxy
+  require_relative "proxy/failsafe"
+  include Failsafe
+
   attr_accessor :redis, :key
 
   def initialize(redis, key, **options)
@@ -11,16 +14,18 @@ class Kredis::Types::Proxy
   end
 
   def method_missing(method, *args, **kwargs)
-    Kredis.logger&.debug log_message(method, *args, **kwargs)
-    redis.public_send method, key, *args, **kwargs
+    Kredis.instrument :proxy, **log_message(method, *args, **kwargs) do
+      failsafe do
+        redis.public_send method, key, *args, **kwargs
+      end
+    end
   end
 
   private
     def log_message(method, *args, **kwargs)
-      args      = args.flatten.compact_blank.presence
-      kwargs    = kwargs.compact_blank.presence
-      type_name = self.class.name.split("::").last
+      args      = args.flatten.reject(&:blank?).presence
+      kwargs    = kwargs.reject { |_k, v| v.blank? }.presence
 
-      "[Kredis #{type_name}] #{method.upcase} #{key} #{args&.inspect} #{kwargs&.inspect}".chomp
+      { message: "#{method.upcase} #{key} #{args&.inspect} #{kwargs&.inspect}".chomp }
     end
 end

data/lib/kredis/types/proxying.rb

@@ -13,6 +13,10 @@ class Kredis::Types::Proxying
     options.each { |key, value| send("#{key}=", value) }
   end
 
+  def failsafe(returning: nil, &block)
+    proxy.suppress_failsafe_with(returning: returning, &block)
+  end
+
   private
     delegate :type_to_string, :string_to_type, :types_to_strings, :strings_to_types, to: :Kredis
 end

data/lib/kredis/types/scalar.rb

@@ -1,14 +1,20 @@
 class Kredis::Types::Scalar < Kredis::Types::Proxying
-  proxying :set, :get, :exists?, :del
+  proxying :set, :get, :exists?, :del, :expire, :expireat
 
-  attr_accessor :typed, :default
+  attr_accessor :typed, :default, :expires_in
 
   def value=(value)
-    set type_to_string(value)
+    set type_to_string(value), ex: expires_in
   end
 
   def value
-    string_to_type(get, typed) || default
+    value_after_casting = string_to_type(get, typed)
+    
+    if value_after_casting.nil?
+      default
+    else
+      value_after_casting
+    end
   end
 
   def to_s
@@ -22,4 +28,12 @@ class Kredis::Types::Scalar < Kredis::Types::Proxying
   def clear
     del
   end
+
+  def expire_in(seconds)
+    expire seconds.to_i
+  end
+
+  def expire_at(datetime)
+    expireat datetime.to_i
+  end
 end

data/lib/kredis/types/set.rb

@@ -29,7 +29,7 @@ class Kredis::Types::Set < Kredis::Types::Proxying
   end
 
   def size
-    scard
+    scard.to_i
   end
 
   def take

data/lib/kredis/types/slots.rb

@@ -6,23 +6,25 @@ class Kredis::Types::Slots < Kredis::Types::Proxying
   attr_accessor :available
 
   def reserve
-    if block_given?
-      begin
-        if reserve
-          yield
+    failsafe returning: false do
+      if block_given?
+        begin
+          if reserve
+            yield
+            true
+          else
+            false
+          end
+        ensure
+          release
+        end
+      else
+        if incr <= available
           true
         else
+          release
           false
         end
-      ensure
-        release
-      end
-    else
-      if incr <= available
-        true
-      else
-        release
-        false
       end
     end
   end
@@ -32,7 +34,9 @@ class Kredis::Types::Slots < Kredis::Types::Proxying
   end
 
   def available?
-    get.to_i < available
+    failsafe returning: false do
+      get.to_i < available
+    end
   end
 
   def reset

data/lib/kredis/types.rb

@@ -1,73 +1,90 @@
 module Kredis::Types
-  def proxy(key, config: :shared)
-    Proxy.new configured_for(config), namespaced_key(key)
+  autoload :CallbacksProxy, "kredis/types/callbacks_proxy"
+
+  def proxy(key, config: :shared, after_change: nil)
+    type_from(Proxy, config, key, after_change: after_change)
   end
 
 
-  def scalar(key, typed: :string, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: typed, default: default
+  def scalar(key, typed: :string, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: typed, default: default, expires_in: expires_in)
+  end
+
+  def string(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :string, default: default, expires_in: expires_in)
   end
 
-  def string(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :string, default: default
+  def integer(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :integer, default: default, expires_in: expires_in)
   end
 
-  def integer(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :integer, default: default
+  def decimal(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :decimal, default: default, expires_in: expires_in)
   end
 
-  def decimal(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :decimal, default: default
+  def float(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :float, default: default, expires_in: expires_in)
   end
 
-  def float(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :float, default: default
+  def boolean(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :boolean, default: default, expires_in: expires_in)
   end
 
-  def boolean(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :boolean, default: default
+  def datetime(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :datetime, default: default, expires_in: expires_in)
   end
 
-  def datetime(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :datetime, default: default
+  def json(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :json, default: default, expires_in: expires_in)
   end
 
-  def json(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :json, default: default
+
+  def counter(key, expires_in: nil, config: :shared, after_change: nil)
+    type_from(Counter, config, key, after_change: after_change, expires_in: expires_in)
   end
 
+  def cycle(key, values:, expires_in: nil, config: :shared, after_change: nil)
+    type_from(Cycle, config, key, after_change: after_change, values: values, expires_in: expires_in)
+  end
 
-  def counter(key, expires_in: nil, config: :shared)
-    Counter.new configured_for(config), namespaced_key(key), expires_in: expires_in
+  def flag(key, config: :shared, after_change: nil)
+    type_from(Flag, config, key, after_change: after_change)
   end
 
-  def flag(key, config: :shared)
-    Flag.new configured_for(config), namespaced_key(key)
+  def enum(key, values:, default:, config: :shared, after_change: nil)
+    type_from(Enum, config, key, after_change: after_change, values: values, default: default)
   end
 
-  def enum(key, values:, default:, config: :shared)
-    Enum.new configured_for(config), namespaced_key(key), values: values, default: default
+  def hash(key, typed: :string, config: :shared, after_change: nil)
+    type_from(Hash, config, key, after_change: after_change, typed: typed)
   end
 
-  def list(key, typed: :string, config: :shared)
-    List.new configured_for(config), namespaced_key(key), typed: typed
+  def list(key, typed: :string, config: :shared, after_change: nil)
+    type_from(List, config, key, after_change: after_change, typed: typed)
   end
 
-  def unique_list(key, typed: :string, limit: nil, config: :shared)
-    UniqueList.new configured_for(config), namespaced_key(key), typed: typed, limit: limit
+  def unique_list(key, typed: :string, limit: nil, config: :shared, after_change: nil)
+    type_from(UniqueList, config, key, after_change: after_change, typed: typed, limit: limit)
   end
 
-  def set(key, typed: :string, config: :shared)
-    Set.new configured_for(config), namespaced_key(key), typed: typed
+  def set(key, typed: :string, config: :shared, after_change: nil)
+    type_from(Set, config, key, after_change: after_change, typed: typed)
   end
 
-  def slot(key, config: :shared)
-    Slots.new configured_for(config), namespaced_key(key), available: 1
+  def slot(key, config: :shared, after_change: nil)
+    type_from(Slots, config, key, after_change: after_change, available: 1)
   end
 
-  def slots(key, available:, config: :shared)
-    Slots.new configured_for(config), namespaced_key(key), available: available
+  def slots(key, available:, config: :shared, after_change: nil)
+    type_from(Slots, config, key, after_change: after_change, available: available)
   end
+
+  private
+    def type_from(type_klass, config, key, after_change: nil, **options)
+      type_klass.new(configured_for(config), namespaced_key(key), **options).then do |type|
+        after_change ? CallbacksProxy.new(type, after_change) : type
+      end
+    end
 end
 
 require "kredis/types/proxy"
@@ -75,8 +92,10 @@ require "kredis/types/proxying"
 
 require "kredis/types/scalar"
 require "kredis/types/counter"
+require "kredis/types/cycle"
 require "kredis/types/flag"
 require "kredis/types/enum"
+require "kredis/types/hash"
 require "kredis/types/list"
 require "kredis/types/unique_list"
 require "kredis/types/set"

data/lib/kredis/version.rb

@@ -1,3 +1,3 @@
 module Kredis
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/kredis.rb

@@ -1,20 +1,30 @@
-require "kredis/railtie"
+require "active_support"
+require "active_support/core_ext/module/attribute_accessors"
+
 require "kredis/version"
 
 require "kredis/connections"
+require "kredis/log_subscriber"
 require "kredis/namespace"
+require "kredis/type_casting"
 require "kredis/types"
 require "kredis/attributes"
-require "kredis/type_casting"
 
-module Kredis
-  include Connections, Namespace, Types, TypeCasting
+require "kredis/railtie" if defined?(Rails::Railtie)
 
+module Kredis
+  include Connections, Namespace, TypeCasting, Types
   extend self
 
+  autoload :Migration, "kredis/migration"
+
   mattr_accessor :logger
 
   def redis(config: :shared)
     configured_for(config)
   end
+
+  def instrument(channel, **options, &block)
+    ActiveSupport::Notifications.instrument("#{channel}.kredis", **options, &block)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kredis
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-02 00:00:00.000000000 Z
+date: 2021-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -31,14 +31,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 description: 
 email: david@hey.com
 executables: []
@@ -50,16 +64,21 @@ files:
 - lib/kredis.rb
 - lib/kredis/attributes.rb
 - lib/kredis/connections.rb
+- lib/kredis/log_subscriber.rb
 - lib/kredis/migration.rb
 - lib/kredis/namespace.rb
 - lib/kredis/railtie.rb
 - lib/kredis/type_casting.rb
 - lib/kredis/types.rb
+- lib/kredis/types/callbacks_proxy.rb
 - lib/kredis/types/counter.rb
+- lib/kredis/types/cycle.rb
 - lib/kredis/types/enum.rb
 - lib/kredis/types/flag.rb
+- lib/kredis/types/hash.rb
 - lib/kredis/types/list.rb
 - lib/kredis/types/proxy.rb
+- lib/kredis/types/proxy/failsafe.rb
 - lib/kredis/types/proxying.rb
 - lib/kredis/types/scalar.rb
 - lib/kredis/types/set.rb
@@ -78,14 +97,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Higher-level data structures built on Redis.