kredis 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd8ef47e0ef8b83252c6dc0878bf81b6963a6fe959c1f81d776087a255798421
-  data.tar.gz: 04af1db077a8ba58769bb0614830c2fd1395a3a777df1d304c6e63f48753a5bb
+  metadata.gz: 678d0983bf3cb50abb7732dc3c3e4da93764173dbdf03ce367254dbdb9297ef2
+  data.tar.gz: 7209773f020b0d1055171f30f6ff204786f3edf84e5938cd09f55789fd86e934
 SHA512:
-  metadata.gz: cae5b52d7156a5aae222962e9f328bcd954a09aae7d24ff272319ace142cec3ac78c18b7b6bf3a46403c00fbbf0561f9f60a554384195fd7208d88518f261ddf
-  data.tar.gz: 7b5e80312aa4daa05837697080e8ada67d9b1f59fda1f6902c9f9539caa745a703636f04d3576cb9dc86c7bbf23b8f74d0ba58b0beae7bd4aeb4e95abad180c6
+  metadata.gz: 2aa0b22042910eaa558f1bf8e5fed47aa7385d16ba46f63024f9311760a4f2ee74c42dadb3f333388755d1862a04999ca83cc016bf023a3e1a48491f089c7e03
+  data.tar.gz: ff37e6f461fc3117fd7d02116da43931550683581c6327a176f58d3f09ba06b2da538cd27976f01d7922a7ce7bf9768a8c03445b25e3dc62e635f3ac953093e0

data/README.md

@@ -20,6 +20,23 @@ integer = Kredis.integer "myinteger"
 integer.value = 5  # => SET myinteger "5"
 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"
 json.value = { "one" => 1, "two" => "2" }  # => SET myjson "{\"one\":1,\"two\":\"2\"}"
 { "one" => 1, "two" => "2" } == json.value  # => GET myjson
@@ -29,87 +46,110 @@ There are data structures for counters, enums, flags, lists, unique lists, sets,
 
 ```ruby
 list = Kredis.list "mylist"
-list << "hello world!"
-[ "hello world!" ] == list.elements
+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 ])        # => LPUSH myintegerlist "1" "2" "3"
-integer_list << 4                       # => LPUSH myintegerlist "4"
-[ 1, 2, 3, 4 ] == integer_list.elements # LRANGE 0 -1
+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 ])
-unique_list.prepend(%w[ 1 2 3 4 ])
+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"
-unique_list.remove(3)
-[ "1", "2", "4", "5" ] == unique_list.elements
+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
+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
-head_count.increment
-head_count.decrement
+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         # => SETEX "mycounter" 900 0 + INCR "mycounter" 2
+counter.increment by: 2         # => SET mycounter 0 EX 5 NX + INCRBY "mycounter" 2
 2 == counter.value              # => GET "mycounter"
 sleep 6.seconds
 0 == counter.value              # => GET "mycounter"
 
 cycle = Kredis.cycle "mycycle", values: %i[ one two three ]
-:one == cycle.value
-cycle.next
-:two == cycle.value
-cycle.next
-:three == cycle.value
-cycle.next
-:one == cycle.value
+: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
-true == enum.one?
-enum.value = "two"
-"two" == enum.value
+"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
-enum.reset
-"one" == enum.value
+"two" == enum.value             # => GET myenum
+enum.reset                      # => DEL myenum
+"one" == enum.value             # => GET myenum  
 
 slots = Kredis.slots "myslots", available: 3
-true == slots.available?
-slots.reserve
-true == slots.available?
-slots.reserve
-true == slots.available?
-slots.reserve
-true == slots.available?
-slots.reserve
-false == slots.available?
-slots.release
-true == slots.available?
-slots.reset
+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?
-flag.mark
-true == flag.marked?
-flag.remove
-false == flag.marked?
-
-flag.mark(expires_in: 1.second)
-true == flag.marked?
+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?
+true == flag.marked?            #=> EXISTS myflag
 sleep 0.6.seconds
-false == flag.marked?
+false == flag.marked?           #=> EXISTS myflag
 ```
 
 And using structures on a different than the default `shared` redis instance, relying on `config/redis/secondary.yml`:
@@ -133,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
 
@@ -165,6 +216,32 @@ test:
 
 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)
-      kredis_connection_with __method__, name, key, config: config
+    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)
-      kredis_connection_with __method__, name, key, typed: typed, config: config
+    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_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_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_set(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_slot(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, 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_slots(name, available:, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, available: available, 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_counter(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
+    end
+
+    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
@@ -84,4 +99,11 @@ module Kredis::Attributes
     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,19 +6,21 @@ 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 do |connection|
-      if Kredis.namespace
-        keys = connection.keys("#{Kredis.namespace}:*")
-        connection.del keys if keys.any?
-      else
-        connection.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

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

@@ -22,8 +22,9 @@ class Kredis::Migration
     namespaced_to = Kredis.namespaced_key(to)
 
     if to.present? && from != namespaced_to
-      log_migration "Migrating key #{from} to #{namespaced_to}"
-      @redis.evalsha @copy_sha, keys: [ 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 blank/unaltered migration key #{from} → #{to}"
     end
@@ -46,7 +47,7 @@ class Kredis::Migration
       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

@@ -9,7 +9,7 @@ class Kredis::Railtie < ::Rails::Railtie
   end
 
   initializer "kredis.logger" do
-    Kredis.logger = config.kredis.logger || Rails.logger
+    Kredis::LogSubscriber.logger = config.kredis.logger || Rails.logger
   end
 
   initializer "kredis.configurator" do

data/lib/kredis/type_casting.rb

@@ -1,3 +1,5 @@
+require "json"
+
 module Kredis::TypeCasting
   class InvalidType < StandardError; end
 
@@ -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

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/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.rb

@@ -14,9 +14,10 @@ class Kredis::Types::Proxy
   end
 
   def method_missing(method, *args, **kwargs)
-    failsafe do
-      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
 
@@ -24,8 +25,7 @@ class Kredis::Types::Proxy
     def log_message(method, *args, **kwargs)
       args      = args.flatten.reject(&:blank?).presence
       kwargs    = kwargs.reject { |_k, v| v.blank? }.presence
-      type_name = self.class.name.split("::").last
 
-      "[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/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.rb

@@ -1,77 +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)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :string, default: default
+  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 integer(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :integer, 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 decimal(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :decimal, 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 float(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :float, 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 boolean(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :boolean, 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 datetime(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :datetime, 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 json(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :json, 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 counter(key, expires_in: nil, config: :shared)
-    Counter.new configured_for(config), namespaced_key(key), expires_in: expires_in
+  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 cycle(key, values:, expires_in: nil, config: :shared)
-    Cycle.new configured_for(config), namespaced_key(key), values: values, 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"
@@ -82,6 +95,7 @@ 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.3"
+  VERSION = "0.3.0"
 end

data/lib/kredis.rb

@@ -4,6 +4,7 @@ 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"
@@ -13,12 +14,17 @@ 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,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: kredis
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
 - David Heinemeier Hansson
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-11 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:
     - - ">="
@@ -39,7 +39,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
-description:
+- !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: []
 extensions: []
@@ -50,15 +64,18 @@ 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
@@ -72,7 +89,7 @@ homepage: https://github.com/rails/kredis
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -87,8 +104,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: Higher-level data structures built on Redis.
 test_files: []