me-redis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a72bf4245ee1c3efe20256d83c4999e0002d78ea
+  data.tar.gz: 02acdfc1108cc6a3e06b04885b901fa1b63e7c95
+SHA512:
+  metadata.gz: cc66f942a6f49e9c86678ee7f92fdd2dbac60edd77df7b2a7feecde527769a0629da6f06b2d52bd7f5e9c1d9d9ac96a5905bc3ee17658e75d90336d31b5978e4
+  data.tar.gz: 5e699108252163cda89cfd604189343ad38c91a4dc4908d0aaefc890690415109ac6aa8d144a4846b350d20ffaf4e79c09292405fc69c3dffa30731ef6db7db9

data/.gitignore

@@ -0,0 +1,10 @@
+/.idea/
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.6
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in me-redis.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 alekseyl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,408 @@
+# MeRedis
+
+Me - Memory Efficient
+
+This gem is delivering memory optimizations for Redis with slightest code changes.
+
+To understand optimizations and how to use them 
+I suggest you to read my paper this topic: https://medium.com/p/61076c7da4c
+
+#Features:
+ 
+* seamless integration with code already in use, hardest integration possible: 
+add me_ prefix to some of your methods ( me_ methods implement hash memory optimization ). 
+It's all in MeRedis configuration, not your current code. 
+
+* hash key/value optimization with seamless code changes, 
+you can replace set('object:id', value) with me_set( 'object:id', value) 
+and free 90 byte for each ['object:id', value] pair. 
+
+* zips user-friendly key crumbs according to configuration, i.e. converts for example user:id to u:id
+
+* zip integer parts of a keys with base62 encoding. Since all keys in redis are always strings, than we don't care for integers parts base, and by using base62 encoding we can 1.8 times shorten integer crumbs of keys 
+
+* respects pipelined and multi, properly works with Futures. 
+
+* allow different compressors for a different key namespaces, 
+   you can deflate separately objects, short strings, large strings, primitives. 
+
+* hot migration module with fallbacks to previous keys.
+
+* rails-less, it's rails independent, you can use it apart from rails
+
+* seamless refactoring of old crumbs, i.e. you may rename crumbs keeping 
+  existing cache intact 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'me-redis'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install me-redis
+
+## Usage
+
+**Main consideration:**
+1) less memory on redis side is better than less performance on ruby side
+2) more result with less code changes,
+   i.e. overriding native redis methods with proper configuration basis is 
+   preferred over mixin new methods
+
+MeRedis based on three general optimization ideas:
+* shorten keys
+* compress values 
+* 'zip to hash', a Redis specific optimization from [Redis official memory optimization guide](https://medium.com/r/?url=https%3A%2F%2Fredis.io%2Ftopics%2Fmemory-optimization)
+
+
+Thats why MeRedis contains three modules : MeRedis::ZipKeys, MeRedis::ZipValues, MeRedis::ZipToHash.
+
+They can be used separately in any combination, but the simplest 
+way to deal with them all is call include upon MeRedis:
+
+```ruby 
+   Redis.include(MeRedis)
+   redis = Redis.new
+``` 
+
+If you want to keep a clear Redis class, you can do this way:
+
+```ruby
+   me_redis = Class.new(Redis).include(MeRedis).configure({...}).new
+```
+
+So now me_redis is a instance of unnamed class derived from Redis, 
+and patched with all MeRedis modules. 
+
+If you want to include them separately look at MeRedis.included method:
+
+```ruby
+  def self.included(base)
+    base.prepend( MeRedis::ZipValues )
+    base.prepend( MeRedis::ZipKeys )
+    base.include( MeRedis::ZipToHash )
+  end
+```
+
+This is the right chain of prepending/including, so just remove unnecessary module.
+
+###Base use
+
+```ruby
+  redis = Redis.new
+  me_redis = Class.new(Redis).include(MeRedis).configure({
+    hash_max_ziplist_entries: 64,
+    zip_crumbs: :user,
+    integers_to_base62: true,
+    compress_namespaces: :user
+  }).new
+
+  # keep using code as you already do, like this:
+  me_redis.set( 'user:100', @user.to_json )
+  me_redis.get( 'user:100' )
+    
+  # is equal under a hood to: 
+  redis.set( 'u:1C', Zlib.deflate( @user.to_json ) )
+  Zlib.inflate( redis.get( 'u:1C' ) )
+  
+  #OR replace all get/set/incr e.t.c with me_ prefixed version like this:
+  me_redis.me_set( 'user:100', @user.to_json )
+  me_redis.me_get( 'user:100' )
+  
+  # under the hood equals to:
+  redis.hset( 'u:1', 'A', Zlib.deflate( @user.to_json ) )
+  Zlib.inflate( redis.hget( 'u:1', 'A' ) )
+      
+  # future works same
+  ftr, me_ftr = nil, nil
+  me_redis.pipelined{ me_redis.set('user:100', '111'); me_ftr = me_redis.get(:user) } 
+  #is equal to:
+  redis.pipelined{ redis.set( 'u:1C', Zlib.defalte( '111' ) ); ftr = redis.get('u:1C') }
+  # and
+  me_ftr.value == ftr.value 
+  
+```
+
+As you can see you can get a result with smallest or even none code changes!
+
+All the ideas is to move complexity to config.
+   
+###Config
+```ruby
+
+  Redis.include(MeRedis).configure( hash_max_ziplist_entries: 512 ) 
+
+  #Options are: 
+  
+    # if set - configures Redis hash_max_ziplist_entries value,
+    # otherwise it will be filled from Redis hash-max-ziplist-value
+    :hash_max_ziplist_entries
+    
+    # if set - configures Redis hash_max_ziplist_entries value,
+    # otherwise it will be filled from Redis hash-max-ziplist-value
+    :hash_max_ziplist_value
+     
+    # array or hash or string/sym of keys crumbs to zip, 
+    # if a hash given it used as is,
+    # otherwise MeRedis tries to construct hash by using first char from each key given 
+    # + integer in base62 starting from 1 for subsequent appearence of a crumbs starting with same chars
+    :zip_crumbs
+    
+    # set to true if you want to zip ALL integers in keys to base62 form
+    :integers_to_base62
+    
+    # regexp composed from zip_crumbs keys and general integer regexp (\d+) if integers_to_base62 is set
+    # better not to set directly
+    :key_zip_regxp
+    
+    # keys prefixes/namespaces for values need to be zipped,
+    # acceptable formats:
+    # 1. single string/symbol/regexp - will map it to default compressor
+    # 2. array of string/symbols/regexp will map them all to default compressor
+    # 3. hash maps different kinds of 1 and 2 to custom compressors
+    
+    # compress_namespaces will convert to two regexp: 
+    #  1. one for strings and symbols 
+    #  2. second for regexps 
+    #  they both will start with \A meaning this is a namespace/prefix 
+    #  be aware of it and omit \A in your regexps 
+    :compress_namespaces
+    
+    # if set directly than default_compressor applied to any key matched this regexp 
+    # compress_namespaces is ignored  
+    :compress_ns_regexp
+    
+    # any kind of object which responds to compress/decompress methods
+    :default_compressor
+```
+  ###Config examples
+  
+```ruby
+
+redis = Redis.include( MeRedis ).new
+
+# zip key crumbs 'user', 'card', 'card_preview', to u, c, c1
+# zips integer crumbs to base62, 
+# for keys starting with gz prefix compress values with Zlib 
+# for keys starting with json values with ActiveRecordJSONCompressor
+Redis.configure( 
+  hash_max_ziplist_entries: 256,
+  zip_crumbs: %i[user card card_preview json], # -> { user: :u, card: :c, card_preview: :c1 }
+  integers_to_base62: true,
+  compress_namespaces: {
+      gz: MeRedis::ZipValues::ZlibCompressor,
+      json: ActiveRecordJSONCompressor 
+  }
+)
+
+ redis.set( 'gz/card_preview:62', @card_preview )
+
+#is equal under hood to:
+ redis.set( 'gz/c0:Z', Zlib.deflate( @card_preview) )
+
+# and using me_ method:
+ redis.me_set( 'gz/card_preview:62', @card_preview )
+ 
+#under the hood converts to:
+  redis.hset( 'gz/c0:1', '0', Zlib.deflate( @card_preview ) )
+
+    
+# It's possible to intersect zip_crumbs with compress_namespaces
+Redis.configure( 
+  hash_max_ziplist_entries: 256,
+  zip_crumbs: %i[user card card_preview json], # -> { user: :u, card: :c, card_preview: :c1 }
+  integers_to_base62: true,
+  compress_namespaces: {
+      gz: MeRedis::ZipValues::ZlibCompressor,
+      [:user, :card] => ActiveRecordJSONCompressor 
+  } 
+)
+
+redis.set( 'user:62', @user )
+#under hood now converted to
+redis.set( 'u:Z', ActiveRecordJSONCompressor.compress( @user ) )
+
+#It's possible for compress_namespaces to use regexp:
+Redis.configure( 
+  zip_crumbs: %i[user card card_preview json], # -> { user: :u, card: :c, card_preview: :c1 }
+  compress_namespaces: {
+      /organization:[\d]+:card_preview/ => MeRedis::ZipValues::ZlibCompressor,
+      [:user, :card].map{|crumb| /organization:[\d]+:#{crumb}/ } => ActiveRecordJSONCompressor 
+  }
+)
+
+redis.set( 'organization:1:user:62', @user )
+#under hood now converted to
+redis.set( 'organization:1:u:Z', ActiveRecordJSONCompressor.compress( @user ) )
+
+# If you want intersect key zipping with regexp 
+# **you must intersect them using substituted crumbs!!!**
+
+Redis.configure( 
+  integers_to_base62: true,
+  zip_crumbs: %i[user card card_preview organization], # -> { user: :u, card: :c, card_preview: :c1, organization: :o }
+  compress_namespaces: {
+      /o:[a-zA-Z\d]+:card_preview/ => MeRedis::ZipValues::ZlibCompressor,
+      [:user, :card].map{|crumb| /o:[a-zA-Z\d]+:#{crumb}/ } => ActiveRecordJSONCompressor 
+  }
+)
+
+redis.set( 'organization:1:user:62', @user )
+#under hood now converted to
+redis.set( 'o:1:u:Z', ActiveRecordJSONCompressor.compress( @user ) )
+
+# You may set key zipping rules directly with a hash:
+Redis.configure( 
+  hash_max_ziplist_entries: 256,
+  zip_crumbs: { user: :u, card: :c, card_preview: :cp],
+  integers_to_base62: true,
+)
+
+# This config means: don't zip keys only zip values. 
+# For keys started with :user, :card, :card_preview 
+# compress all values with default compressor 
+# default compressor is ZlibCompressor if you prepend ZipValues module or include whole MeRedis module,
+# otherwise it is EmptyCompressor which doesn't compress anything 
+Redis.configure( 
+  hash_max_ziplist_entries: 256,
+  compress_namespaces: %i[user card card_preview]
+)
+```
+Now I may suggest some best practices for MeRedis configure:
+
+* explicit crumbs schema is preferable over implicit
+* if you are going lazy, and use implicit schemas, than avoid keys shuffling, 
+  cause it messes with your cache
+* better to configure hash-max-ziplist-* in MeRedis.configure than elsewhere.
+* use in persistent Redis-based system with extreme caution
+  
+ 
+#Custom Compressors
+
+MeRedis allow you to compress values through different compressor. 
+Here is an example of custom compressor for ActiveRecord objects, 
+I use to test compression ratio against plain compression of to_json. 
+
+```ruby
+
+module ActiveRecordJSONCompressor
+  # this is the example, automated for simplicity, if DB schema changes, than cache may broke!!
+  # in reallife scenario either invalidate cache, or use explicit schemas
+  # like User: { first_name: 1, last_name: 2 ... }, 
+  # than your cache will be safer on schema changes.
+  COMPRESSOR_SCHEMAS = [User, HTag].map{|mdl|
+    [mdl.to_s, mdl.column_names.each_with_index.map{ |el, i| [el, (20 + i).to_base62] }.to_h]
+  }.to_h.with_indifferent_access
+
+  REVERSE_COMPRESSOR_SCHEMA = COMPRESSOR_SCHEMAS.dup.transform_values(&:invert)
+
+  def self.compress( object )
+    use_schema = COMPRESSOR_SCHEMAS[object.class.to_s]
+    # _s - shorten for schema, s cannot be used since its a number in Base62 system
+    Zlib.deflate(
+        object.serializable_hash
+            .slice( *use_schema.keys )
+            .transform_keys{ |k| use_schema[k] }
+            .reject{ |_,v| v.blank? }
+            .merge!( _s: object.class.to_s ).to_json
+    )
+  end
+
+  def self.decompress(value)
+    compressed_hash = JSON.load( Zlib.inflate(value) )
+    model = compressed_hash.delete('_s')
+    schema = REVERSE_COMPRESSOR_SCHEMA[model]
+    model.constantize.new( compressed_hash.transform_keys{ |k| schema[k] } )
+  end
+end
+
+```
+
+#Hot migration 
+MeRedis deliver additional module for hot migration to KeyZipping and ZipToHash. 
+We don't need one in generally for base implementation of ZipValues cause 
+its getter methods fallbacks to value. 
+
+###Features
+* mget hget hgetall get exists type getset - fallbacks for key_zipping
+* me_get me_mget - fallbacks for hash zipping
+* partially respects pipelining and multi 
+* protecting you from accidentally do many to less many migration 
+  and from ZipToHash migration without key zipping ( 
+    though it's impossible to hot migrate from 'user:100' to 'user:1', 'B', 
+    because of same namespace 'user' for flat key/value pair and hashes, 
+    you'll definetely get an error ) 
+* reverse migration methods
+
+```ruby
+  redis = Redis.include( MeRedisHotMigrator ).configure( 
+    zip_crumbs: :user 
+  )
+  
+  usr_1_cache = redis.me_get('user:1')
+  
+  all_user_keys = redis.keys('user*') 
+  redis.migrate_to_hash_representation( all_user_keys )
+  
+  usr_1_cache == redis.me_get('user:1') # true
+  
+  redis.reverse_from_hash_representation!( all_user_keys )
+  
+  usr_1_cache == redis.me_get('user:1') # true
+
+```
+
+For persistent store use with extreme caution!! 
+Backup, test, test, user test and after you are sure than you may migrate. 
+
+Try not to stuck with it because doing double amount of actions, 
+do BG deploy of code, run migration in parallel, replace MeRedisHotMigrator with MeRedis
+do BG deploy and you are done. 
+
+#Limitations
+
+###Me_* methods limitation
+
+Some of me_methods like me_mget/me_mset/me_getset 
+are imitations for corresponded base methods behaviour through 
+pipeline and transactions. So inside pipelined call it may not 
+deliver a completely equal behaviour. 
+
+me_mget has an additional double me_mget_p in case you need to use it with futures. 
+
+###ZipKeys and ZipValues
+As I already mention if you want to use custom prefix regex 
+for zipping values than it must be constructed with a crumbs substitutions, 
+not the original crumb, see config example. 
+
+```ruby
+
+```
+                 
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/alekseyl/me-redis.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## ToDo List
+
+* add keys method 
+* refactor readme

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "me_redis"
+
+# 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.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/me_redis.rb

@@ -0,0 +1,189 @@
+require 'me_redis/version'
+require 'me_redis/zip_keys'
+require 'me_redis/zip_to_hash'
+require 'me_redis/zip_values'
+require 'me_redis/me_redis_hot_migrator'
+require 'me_redis/integer'
+require 'me_redis/hash'
+
+require 'zlib'
+
+# Main ideas:
+# 1) less memory on redis is better than performance on ruby code
+# 2) more result with less code changes,
+#    i.e. overriding old methods with proper configure is preferred over mixin new methods
+# 3) rails-less
+
+module MeRedis
+  module ClassMethods
+
+    def configure( config = nil )
+      # at start they are nils, but at subsequent calls they may not be nils
+      me_config.key_zip_regxp = nil
+      me_config.compress_ns_regexp = nil
+      @zip_ns_finder = nil
+
+      config.each{ |key,value| me_config.send( "#{key}=", value ) } if config
+
+      yield( me_config ) if block_given?
+
+
+      prepare_zip_crumbs
+      prepare_compressors
+
+      # useful for chaining with dynamic class creations
+      self
+    end
+
+    def me_config
+      @me_config ||= Struct.new(
+          # if set - configures Redis hash_max_ziplist_entries value,
+          # otherwise it will be filled from Redis hash-max-ziplist-value
+          :hash_max_ziplist_entries,
+          # same as above only for value, only resets it globally if present
+          :hash_max_ziplist_value,
+          # array or hash or string/sym of key crumbs to zip, if a hash given it used as is,
+          # otherwise meredis tries to construct hash by using first char from each key + integer in base62 form for
+          # subsequent appearence of a crumb starting with same char
+          :zip_crumbs,
+          # zip integers in keys to base62 form
+          :integers_to_base62,
+          # regex composed from zip_crumbs keys and integer regexp if integers_to_base62 is set
+          :key_zip_regxp,
+          # prefixes/namespaces for keys need zipping,
+          # acceptable formats:
+          # 1. single string/sym will map it to defauilt compressor
+          # 2. array of string/syms will map it to defauilt compressor
+          # 3. hash maps different kinds of 1 and 2 to custom compressors
+          :compress_namespaces,
+          # if configured than default_compressor used for compression of all keys matched and compress_namespaces is ignored
+          :compress_ns_regexp,
+
+          :default_compressor
+      ).new(512)
+    end
+
+    def zip_crumbs; me_config.zip_crumbs end
+
+    def key_zip_regxp
+      return me_config.key_zip_regxp if me_config.key_zip_regxp
+      regexp_parts = []
+      #reverse order just to be sure we replaced longer strings before shorter
+      # also we need to sort by length, not just sort, because we must try to replace 'z_key_a'  first,
+      # and only after that we can replace 'key'
+      regexp_parts <<  "(#{zip_crumbs.keys.sort_by(&:length).reverse.join('|')})" if zip_crumbs
+      regexp_parts << '(\d+)' if me_config.integers_to_base62
+      me_config.key_zip_regxp ||= /#{regexp_parts.join('|')}/
+    end
+
+    def get_compressor_namespace_from_key( key )
+      ns_matched = zip_ns_finder[:rgxps_ns] && key.match(zip_ns_finder[:rgxps_ns])
+      if ns_matched&.captures
+        zip_ns_finder[:rgxps_arr][ns_matched.captures.each_with_index.find{|el,i| el}[1]]
+      else
+        zip_ns_finder[:string_ns] && key.match(zip_ns_finder[:string_ns])&.send(:[], 0)
+      end
+    end
+
+    def zip?(key)
+      me_config.compress_ns_regexp&.match?(key) ||
+          zip_ns_finder[:string_ns]&.match?(key) ||
+          zip_ns_finder[:rgxps_ns]&.match?(key)
+    end
+
+    def zip_ns_finder
+      return @zip_ns_finder if @zip_ns_finder
+      regexps_compress_ns = me_config.compress_namespaces.keys.select{|key| key.is_a?(Regexp) }
+      strs_compress_ns = me_config.compress_namespaces.keys.select{|key| !key.is_a?(Regexp) }
+
+      @zip_ns_finder = {
+          string_ns: strs_compress_ns.length == 0 ? nil : /\A(#{strs_compress_ns.sort_by(&:length).reverse.join('|')})/,
+          rgxps_ns: regexps_compress_ns.length == 0 ? nil : /\A#{regexps_compress_ns.map{|rgxp| "(#{rgxp})" }.join('|')}/,
+          rgxps_arr: regexps_compress_ns
+      }
+    end
+
+    def get_compressor_for_key( key )
+      if me_config.compress_ns_regexp
+        me_config.default_compressor
+      else
+        me_config.compress_namespaces[get_compressor_namespace_from_key( key )]
+      end
+    end
+
+    private
+
+    def prepare_zip_crumbs
+      if zip_crumbs.is_a?( Array )
+        result = {}
+        me_config.zip_crumbs.map!(&:to_s).each do |sub|
+          if result[sub[0]]
+            i = 0
+            begin i += 1 end while( result["#{sub[0]}#{i.to_base62}"] )
+            result["#{sub[0]}#{i.to_base62}"] = sub.to_s
+          else
+            result[sub[0]] = sub
+          end
+        end
+        me_config.zip_crumbs = result.invert
+      elsif zip_crumbs.is_a?( String ) || zip_crumbs.is_a?( Symbol )
+        me_config.zip_crumbs = { me_config.zip_crumbs.to_s => me_config.zip_crumbs[0] }
+      elsif zip_crumbs.is_a?( Hash )
+        me_config.zip_crumbs = zip_crumbs.transform_keys(&:to_s).transform_values(&:to_s)
+        raise ArgumentError.new("pack subs cannot be inverted properly.
+                repack subs: #{zip_crumbs}, repack keys invert: #{zip_crumbs.invert}") unless zip_crumbs.invert.invert == zip_crumbs
+      elsif zip_crumbs
+        raise ArgumentError.new("Wrong class for zip_crumbs, expected Array, Hash, String or Symbol! Got: #{zip_crumbs.class.to_s}")
+      end
+
+      key_zip_regxp
+    end
+
+    def prepare_compressors
+
+      me_config.default_compressor ||= MeRedis::ZipValues::EmptyCompressor
+
+      me_config.compress_namespaces = case me_config.compress_namespaces
+                                        when Array
+                                          me_config.compress_namespaces.map{|ns| [replace_ns(ns), me_config.default_compressor] }.to_h
+                                        when String, Symbol, Regexp
+                                          { replace_ns( me_config.compress_namespaces ) => me_config.default_compressor }
+                                        when Hash
+                                          me_config.compress_namespaces.inject({}) do |sum, (name_space, compressor)|
+                                            name_space.is_a?( Array ) ?
+                                                sum.merge!( name_space.map{ |ns| [replace_ns( ns), compressor] }.to_h )
+                                                : sum[replace_ns(name_space)] = compressor
+                                            sum
+                                          end
+                                        else
+                                          raise ArgumentError.new(<<~NS_ERR) if me_config.compress_namespaces
+            Wrong class for compress_namespaces, expected Array, 
+                                Hash, String or Symbol! Got: #{me_config.compress_namespaces.class.to_s}
+                                          NS_ERR
+                                          {}
+                                      end
+
+      zip_ns_finder
+    end
+
+    def replace_ns(ns)
+      ( zip_crumbs && zip_crumbs[ns.to_s] ) || ( check_ns_type!(ns) && ( ns.is_a?(Regexp) ? ns : ns.to_s ) )
+    end
+
+    def check_ns_type!( ns )
+      case ns
+        when String, Symbol, Regexp
+          true
+        else
+          raise 'Must be Symbol, String or Regexp!'
+      end
+    end
+  end
+
+  #include
+  def self.included(base)
+    base.prepend( MeRedis::ZipValues )
+    base.prepend( MeRedis::ZipKeys )
+    base.include( MeRedis::ZipToHash )
+  end
+end

data/lib/me_redis/hash.rb

@@ -0,0 +1,29 @@
+class Hash
+  # Returns a new hash with all keys converted using the +block+ operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
+  #
+  # If you do not provide a +block+, it will return an Enumerator
+  # for chaining with other methods:
+  #
+  #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) { size } unless block_given?
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+  # Destructively converts all keys using the +block+ operations.
+  # Same as +transform_keys+ but modifies +self+.
+  def transform_keys!
+    return enum_for(:transform_keys!) { size } unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+end unless Hash.method_defined?(:transform_keys)

data/lib/me_redis/integer.rb

@@ -0,0 +1,7 @@
+require 'base62-rb'
+
+class Integer
+  def to_base62
+    Base62.encode(self )
+  end
+end

data/lib/me_redis/me_redis_hot_migrator.rb

@@ -0,0 +1,138 @@
+#We need only to fallback getters, when you are setting
+# new value it will go in a new place already
+# me_mget doesn't compartible with pipeline, it will raise exception when placed inside one.
+module MeRedisHotMigrator
+  ZK_FALLBACK_METHODS = %i[mget hget hgetall get exists type getset]
+
+  def self.included(base)
+    base::Future.prepend(FutureMigrator)
+
+    base.class_eval do
+      ZK_FALLBACK_METHODS.each do |method|
+        alias_method "_#{method}", method
+      end
+
+      include(MeRedis)
+
+      def me_get( key )
+        prev_future = _get( key ) unless @client.is_a?(self.class::Client)
+        newvl = super(key)
+
+        newvl.prev_future = prev_future if newvl.is_a?(self.class::Future)
+        newvl || _get( key )
+      end
+
+      def me_mget(*keys)
+        #cannot run in pipeline because of fallbacks
+        raise 'Cannot run in pipeline!!!' unless @client.is_a?(self.class::Client)
+        me_mget_p(*keys).map(&:value)
+      end
+
+    end
+
+    base.prepend( MeRedisHotMigrator::PrependMethods )
+  end
+
+  module PrependMethods
+    ZK_FALLBACK_METHODS.each do |method|
+      define_method(method) do |*args|
+        prev_future = send("_#{method}", *args) unless @client.is_a?(self.class::Client)
+        newvl = super(*args)
+
+        newvl.prev_future = prev_future if newvl.is_a?(self.class::Future)
+
+        if method != :mget
+          newvl || send("_#{method}", *args)
+        else
+          newvl.is_a?(Array) ? newvl.zip( send("_#{method}", *args) ).map!{|nvl, oldv| nvl || oldv } : newvl
+        end
+
+      end
+    end
+  end
+
+
+  #-------------------------------ME method migration------------------------------
+  #check if migration possible, if not raises exception with a reason
+  def hash_migration_possible?( keys )
+    result = keys.map{ |key| [split_key(key).each_with_index.map{|v,i| i == 0 ? zip_key(v) : v }, key] }.to_h
+
+    raise ArgumentError.new( "Hash zipping is not one to one! #{result.keys} != #{keys}" ) if result.length != keys.length
+
+    result.each do |sp_key, key|
+      key_start = key.to_s.scan(/\A(.*?)(\d+)\z/).flatten[0]
+      if sp_key[0].start_with?( key_start )
+        raise ArgumentError.new( "#{sp_key[0]} contains original key main part: #{key_start} Hash migration must be done with key zipping!")
+      end
+    end
+
+    true
+  end
+
+  # keys will exists after migrate, you need to call del(keys) directly
+  # uses hsetnx, meaning you will not overwrtite new values
+  def migrate_to_hash_representation( keys )
+    raise StandardError.new('Cannot migrate inside pipeline.') unless @client.is_a?( self.class::Client )
+    raise ArgumentError.new('Migration is unavailable!') unless hash_migration_possible?( keys )
+
+    values = mget( keys )
+    pipelined do
+      keys.each_with_index do |key, i|
+        me_setnx( key, values[i] )
+      end
+    end
+  end
+
+  def reverse_from_hash_representation!( keys )
+    raise "Cannot migrate inside pipeline" unless @client.is_a?(self.class::Client )
+    values = me_mget( keys )
+
+    pipelined do
+      keys.each_with_index{|key, i| set( key, values[i] ) }
+    end
+  end
+  #-------------------------------ME method migration ENDED------------------------
+
+  # -------------------------------KZ migration------------------------------------
+  def migrate_to_key_zipping(keys)
+    pipelined do
+      zk_map_keys(keys).each{|new_key, key| renamenx( key, new_key )}
+    end
+  end
+
+  # reverse migration done with same set of keys, i.e,
+  # if you migrated [ user:1, user:2 ] with migrate_to_key_zipping and want to reverse migration
+  # then use same argument [ user:1, user:2 ]
+  def reverse_from_key_zipping!( keys )
+    pipelined do
+      zk_map_keys(keys).each{|new_key, key| rename( new_key, key ) }
+    end
+  end
+
+  # use only uniq keys! or zk_map_keys will fire an error!
+  # if transition is not one to one zk_map_keys would also fire an error
+  def zk_map_keys(keys)
+    keys.map{ |key| [zip_key(key), key] }.to_h
+        .tap{ |result| raise ArgumentError.new( "Key zipping is not one to one! #{result.keys} != #{keys}" ) if result.length != keys.length }
+  end
+
+  def key_zipping_migration_reversible?( keys )
+    !!zk_map_keys(keys)
+  end
+  # -------------------------------KZ migration ENDED ------------------------------------
+
+  module FutureMigrator
+    def prev_future=(new_prev_future); @prev_future = new_prev_future end
+    def value;
+      vl = super
+      if !vl
+        @prev_future&.value
+      elsif vl.is_a?(Array) && @prev_future
+        vl.zip( @prev_future&.value ).map{|nvl, old| nvl || old }
+      else
+        vl
+      end
+    end
+  end
+
+end

data/lib/me_redis/version.rb

@@ -0,0 +1,3 @@
+module MeRedis
+  VERSION = "0.1.0"
+end

data/lib/me_redis/zip_keys.rb

@@ -0,0 +1,53 @@
+module MeRedis
+  # how to use:
+  # Redis.prepend( MeRedis::KeyMinimizer )
+  module ZipKeys
+
+    def self.prepended(base)
+      base.extend( MeRedis::ClassMethods )
+    end
+
+    def zip_key( key )
+      key.to_s.split( self.class.key_zip_regxp ).map do |zip_me|
+        if zip_me.to_i != 0
+          zip_me.to_i.to_base62
+        else
+          self.class.zip_crumbs&.send(:[], zip_me ) || zip_me
+        end
+      end.join
+    end
+
+    #---- h_methods ---------------------------
+    def hdel( key, hkey ); super( zip_key(key), hkey ) end
+    def hset( key, hkey, value );  super( zip_key(key), hkey, value ) end
+    def hsetnx( key, hkey, value );  super( zip_key(key), hkey, value ) end
+    def hexists( key, hkey ); super( zip_key(key), hkey ) end
+    def hget( key, hkey );  super( zip_key(key), hkey ) end
+    def hincrby( key, hkey, value ); super( zip_key(key), hkey, value ) end
+    def hmset( key, *args ); super( zip_key(key), *args ) end
+    def hmget( key, *args ); super( zip_key(key), *args ) end
+    #---- Hash methods END --------------------
+
+
+    def incr( key ); super( zip_key(key) ) end
+    def get( key ); super( zip_key(key) ) end
+
+    def exists(key); super( zip_key(key) ) end
+    def type(key); super(zip_key(key)) end
+    def decr(key); super(zip_key(key)) end
+    def persist(key); super(zip_key(key)) end
+
+    def decrby( key, decrement ); super(zip_key(key), decrement) end
+    def set( key, value );  super( zip_key(key), value ) end
+    def mset( *key_values ); super( *key_values.each_slice(2).map{ |k,v| [zip_key(k),v] }.flatten ) end
+    def mget( *keys ); super( *keys.map!{ |k| zip_key(k) } ) end
+
+    def getset( key, value );  super( zip_key(key), value ) end
+    def move(key, db); super( zip_key(key), db ) end
+
+    def del(*keys); super( *keys.map{ |key| zip_key(key) } ) end
+
+    def rename(old_name, new_name); super( zip_key(old_name), zip_key(new_name) ) end
+    def renamenx(old_name, new_name); super( zip_key(old_name), zip_key(new_name) ) end
+  end
+end

data/lib/me_redis/zip_to_hash.rb

@@ -0,0 +1,92 @@
+module MeRedis
+  # include
+  module ZipToHash
+
+    module PrependMethods
+      def initialize(*args, &block)
+        super(*args, &block)
+
+        # hash-max-ziplist-entries must be cashed, we can't ask Redis every time we need to zip keys,
+        # cause it's less performant and impossible during pipelining.
+        _config = config(:get, 'hash-max-ziplist-*' )
+        @hash_max_ziplist_entries = _config['hash-max-ziplist-entries'].to_i
+        if self.class.me_config.hash_max_ziplist_entries && @hash_max_ziplist_entries != self.class.me_config.hash_max_ziplist_entries
+          #if me_config configures hash-max-ziplist-entries than we assume it global
+          config(:set, 'hash-max-ziplist-entries', self.class.me_config.hash_max_ziplist_entries )
+        end
+
+        if self.class.me_config.hash_max_ziplist_value &&
+            self.class.me_config.hash_max_ziplist_value != _config['hash-max-ziplist-value'].to_i
+
+          config(:set, 'hash-max-ziplist-value', self.class.me_config.hash_max_ziplist_value)
+        end
+      end
+
+      def config(action, *args)
+        @hash_max_ziplist_entries = args[1].to_i if action.to_s == 'set' && args[0] == 'hash-max-ziplist-entries'
+        super( action, *args )
+      end
+
+    end
+
+    def self.included(base)
+      base.extend( MeRedis::ClassMethods )
+      base.prepend( PrependMethods )
+    end
+
+    def me_del( *keys )
+      keys.length == 1 ? hdel( *split_key(*keys) ) : pipelined{ keys.each{ |key| hdel( *split_key(key) ) } }
+    end
+
+    def me_set( key, value ); hset( *split_key(key), value ) end
+    def me_setnx( key, value ); hsetnx( *split_key(key), value ) end
+    def me_get( key ); hget(*split_key(key)) end
+
+    def me_getset(key, value)
+      # multi returns array of results, also we can use raw results in case of commpression take place
+      # but inside pipeline, multi returns nil
+      ftr = []
+      ( multi{ ftr << me_get( key ); me_set( key, value ) } || ftr )[0]
+    end
+
+    def me_exists?(key); hexists(*split_key(key)) end
+
+    def me_incr(key); hincrby( *split_key(key), 1 ) end
+
+    def me_incrby(key, value); hincrby(*split_key(key), value) end
+
+    # must be noticed it's not a equal replacement for a mset,
+    # because me_mset can be partially executed, since redis doesn't rollbacks partially failed transactions
+    def me_mset( *args )
+      #it must be multi since it keeps an order of commands
+      multi{ args.each_slice(2) { |key, value| me_set( key, value ) } }
+    end
+
+    # be aware: you cant save result of me_mget inside pipeline or multi cause pipeline returns nil
+    def me_mget( *keys )
+      pipelined { keys.each{ |key| me_get( key ) } }
+    end
+
+    # version to be called inside pipeline, to get values, call map(&:value)
+    def me_mget_p( *keys )
+      ftr = []
+      pipelined { keys.each{ |key| ftr << me_get( key ) } }
+      ftr
+    end
+
+    private
+
+    def split_key(key)
+      split = key.to_s.scan(/\A(.*?)(\d+)\z/).flatten
+      raise ArgumentError.new("Cannot split key: #{key}, key doesn't end with the numbers after zipping(#{key})!" ) if split.length == 0
+
+      split[0] = split[0] + (split[1].to_i / @hash_max_ziplist_entries).to_s
+      split[1] = ( split[1].to_i % @hash_max_ziplist_entries)
+      split[1] = split[1].to_base62 if self.class.me_config.integers_to_base62
+
+      split
+    end
+
+  end
+
+end

data/lib/me_redis/zip_values.rb

@@ -0,0 +1,146 @@
+module MeRedis
+  # todo warn in development that gzipped size iz bigger than strict
+  # use prepend for classes or extend on instances
+  module ZipValues
+    module FutureUnzip
+      def set_transformation(&block)
+        return if @transformation_set
+        @transformation_set = true
+
+        @old_transformation = @transformation
+        @transformation = -> (vl) {
+          if @old_transformation
+            @old_transformation.call( block.call(vl, self) )
+          else
+            block.call(vl, self)
+          end
+        }
+        self
+      end
+
+      # patch futures we need only when we are returning values, usual setters returns OK
+      COMMANDS = %i[ incr incrby hincrby get hget getset mget hgetall ].map{|cmd| [cmd, true]}.to_h
+    end
+
+    module PrependMethods
+      def pipelined( &block )
+        super do |redis|
+          block.call(redis)
+          _patch_futures(@client)
+        end
+      end
+
+      def multi( &block )
+        super do |redis|
+          block.call(redis)
+          _patch_futures(@client)
+        end
+      end
+
+      def _patch_futures(client)
+        client.futures.each do |ftr|
+
+          ftr.set_transformation do |vl|
+            if vl && FutureUnzip::COMMANDS[ftr._command[0]]
+              # we only dealing here with GET methods, so it could be hash getters or get/mget
+              keys = ftr._command[0][0] == 'h' ? ftr._command[1,1] : ftr._command[1..-1]
+              if ftr._command[0] == :mget
+                vl.each_with_index.map{ |v, i| zip?(keys[i]) ? self.class.get_compressor_for_key(keys[i]).decompress( v ) : v }
+              elsif zip?(keys[0])
+                compressor = self.class.get_compressor_for_key(keys[0])
+                # on hash commands it could be an array
+                vl.is_a?(Array) ? vl.map!{|v| compressor.decompress( v ) } : compressor.decompress(vl)
+              else
+                vl
+              end
+            else
+              vl
+            end
+          end
+
+        end
+      end
+    end
+
+
+    module ZlibCompressor
+      def self.compress(value); Zlib.deflate(value.to_s ) end
+
+      def self.decompress(value)
+        value ? Zlib.inflate(value) : value
+      rescue Zlib::DataError, Zlib::BufError
+        return value
+      end
+    end
+
+    module EmptyCompressor
+      def self.compress(value); value end
+      def self.decompress(value); value end
+    end
+
+    # for the global gzipping
+    def self.prepended(base)
+      base::Future.prepend(FutureUnzip)
+      base.prepend(PrependMethods)
+
+      base.extend( MeRedis::ClassMethods )
+      base.me_config.default_compressor = MeRedis::ZipValues::ZlibCompressor
+    end
+    # for object extending
+    def self.included(base)
+      base::Future.prepend(FutureUnzip)
+      base.prepend(PrependMethods)
+
+      base.extend( MeRedis::ClassMethods )
+      base.me_config.default_compressor = MeRedis::ZipValues::ZlibCompressor
+    end
+
+    def zip_value(value, key )
+      zip?(key) ? self.class.get_compressor_for_key(key).compress( value ) : value
+    end
+
+    def unzip_value(value, key)
+      return value if value.is_a?( FutureUnzip )
+
+      value.is_a?(String) && zip?(key) ? self.class.get_compressor_for_key(key).decompress( value ) : value
+    end
+
+    def zip?(key); self.class.zip?(key) end
+
+    # Redis prepended methods
+    def get( key ); unzip_value( super( key ), key) end
+    def set( key, value ); super( key, zip_value(value, key) ) end
+
+    def mget(*args); unzip_arr_or_future(super(*args), args ) end
+    def mset(*args); super( *map_msets_arr(args) ) end
+
+    def getset( key, value ); unzip_value( super( key, zip_value(value, key) ), key ) end
+
+    def hget( key, h_key ); unzip_value( super( key, h_key ), key ) end
+    def hset( key, h_key, value );  super( key, h_key, zip_value(value, key) ) end
+    def hsetnx( key, h_key, value ); super( key, h_key, zip_value(value, key) ) end
+
+    def hmset( key, *args ); super( key, map_hmsets_arr(key, *args) ) end
+
+    def hmget( key, *args ); unzip_arr_or_future( super(key, *args), key ) end
+
+    private
+
+    def unzip_arr_or_future( arr, keys )
+      return arr if arr.is_a?(FutureUnzip)
+
+      arr.tap { arr.each_with_index { |val, i| arr[i] = unzip_value(val,keys.is_a?(Array) ? keys[i] : keys)} }
+    end
+
+    def map_hmsets_arr( key, *args )
+      return args unless zip?(key)
+      counter = 0
+      args.map!{ |kv| (counter +=1).odd? ? kv : zip_value(kv, key ) }
+    end
+
+    def map_msets_arr( args )
+      args.tap { (args.length/2).times{ |i| args[2*i+1] = zip_value(args[2*i+1], args[2*i] ) } }
+    end
+  end
+
+end

data/me-redis.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'me_redis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "me-redis"
+  spec.version       = MeRedis::VERSION
+  spec.authors       = ["alekseyl"]
+  spec.email         = ["leshchuk@gmail.com"]
+
+  spec.summary       = %q{Memory efficient redis extention}
+  spec.description   = %q{Enable to zip keys, zip values and replace simple storage key/value pairs with hash storing}
+  spec.homepage      = "https://github.com/alekseyl/me-redis"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'redis', '>= 3.0'
+  spec.add_dependency 'base62-rb'
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: me-redis
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- alekseyl
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: base62-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Enable to zip keys, zip values and replace simple storage key/value pairs
+  with hash storing
+email:
+- leshchuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/me-redis.iml"
+- ".idea/misc.xml"
+- ".idea/modules.xml"
+- ".idea/workspace.xml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/me_redis.rb
+- lib/me_redis/hash.rb
+- lib/me_redis/integer.rb
+- lib/me_redis/me_redis_hot_migrator.rb
+- lib/me_redis/version.rb
+- lib/me_redis/zip_keys.rb
+- lib/me_redis/zip_to_hash.rb
+- lib/me_redis/zip_values.rb
+- me-redis.gemspec
+homepage: https://github.com/alekseyl/me-redis
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Memory efficient redis extention
+test_files: []