redis_cloud_auto_upgrade 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0af044eab29e571790dc677565d64bd0a19c134
+  data.tar.gz: c015cdc4d6a083ca6c2a1083952e54874ed22a91
+SHA512:
+  metadata.gz: bd1f6049bda02b71a68c38e45ca462661673948a2fd9f49dc140dc71c97e177d0e4261851c2e88161c9c9b9808f05ebf031a8d501e5d1b802168db9aa8f98a08
+  data.tar.gz: 94ddb4fd1c011450ebc3ee8960a4d7090b90067cfc49a04930fa676b1c6f7c87c85209c4177edf7e487d326634a0fd798a19ede46c8f5dccfa8e77f82f9b5c36

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Robert Dober, Guillaume Leseur
+
+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,127 @@
+# redis_cloud_auto_upgrade
+
+## Summary
+
+A gem to allow to automatically upgrade your Redis Cloud Addon on Heroku (via Heroku's platform API)
+in case a certain memory usage treshold is reached.
+
+The following can be configured
+
+- Heroku app and addon
+- Heroku's API key
+- Treshold
+
+Typically it will be used in a background job.
+ 
+## Gotchas
+
+* RedisCloud plan data is hardcoded into the gem for now.
+
+* Only the current Redis instance is used to determine the used memory.
+
+## Usage
+
+### Official API
+
+The following is the defined API as protected by semantic version and being **threadsafe**.
+
+```ruby
+    require 'redis_cloud_auto_upgrade'
+
+    # E.g. in a Sidekiq Worker
+
+    def perform
+      RedisCloudAutoUpgrade.potential_upgrade!(
+        # API key for the Heroku API                              required
+        heroku_api_key: "a88a8aa8-a8a8-4b57-a8aa-8888aa8888aa",
+ 
+        # Id of addon, which must be a rediscloud addon_service   required
+        redis_cloud_id: = "4ceaf719-8a4b-4b8b-8dcf-7852fa79ec44"
+ 
+        # Upgrade as soon as 50% of the available memory is used  defaults to 0.5
+        treshhold: 0.5
+ 
+        # Logging is provided if enabled as follows               optional
+       logger: Rails.logger
+        ) do | upgrade_info |
+          # Callback in case an upgrade is actually done            optional
+          # upgrade_info is a Hash see below for more information
+             ...
+        end
+    end
+```
+
+
+Its return value is false if no upgrade was applied, true otherwise.
+
+However to get more information you can provide a block which will be called with an `OpenStruct` instance, containing the following values
+
+```ruby
+      {
+        updated_at: DateTime,
+        old_plan: "rediscloud:100",
+        new_plan: "rediscloud:200",
+        mem_usage: 12_345_678,           # in bytes
+        mem_usage_in_percent: 65,        # Mem usage that triggered the upgrade
+        treshhold_in_percent: 50         # Mem usage >= treshhold triggers upgrades
+      }
+```
+
+### Inofficial API
+
+Not protected by semantic versioning and **not threadsafe** is the API of the underlying object.
+
+It is however very useful for experimenting:
+
+```ruby
+    
+
+  rcau = RedisCloudAutoUpgrade.new
+  rcau.configure(heroku_api_key: 'aaaaaaaa...', heroku_app_name: 'myapp').configure(treshhold: 0.2) # 20%
+
+  rcau.needs_to_upgrade?    #-> true
+  rcau.configure(treshhold: 0.8)
+  rcau.needs_to_upgrade?    #-> false
+
+  rcau.configure(logger: Logger.new($stdout))
+  
+  rcau.current_redis_cloud_plan #-> rediscloud:100 
+  # Memoized value create a new object if  interested in changing values
+
+  rcau.current_redis_mem_usage  #-> 200300400 bytes, Memoized too
+```
+
+## Developer's Guide
+
+### Testing
+
+We are testing with VCR and in order to setup the cassettes we upgrade a plan to `rediscloud:100` causing some cost.
+
+If you want to test here is how to do it:
+
+N.B. **Any time you test without the VCR cassettes you will spend some cents on the RedisCloud plan upgrade**
+
+* Setup the two env variables `$HEROKU_APP_NAME` and `$HEROKU_API_KEY` correctly.
+
+* Run the tests (this will fill `fixtures/vcr_cassettes` in your local copy, these files are not versioned as they contain your API KEY.)
+
+* As you have just upgraded your Redis Cloud Plan to `rediscloud:100` do downgrade it to minimize the costs
+
+## Dependencies
+
+* [Redis](https://github.com/redis/redis-rb)
+
+* [PlatformAPI](https://github.com/heroku/platform-api)
+
+## References
+
+* [Heroku Platform API / Addons](https://devcenter.heroku.com/articles/platform-api-reference#add-on)
+
+## Copyright
+
+MIT, c.f. [LICENSE](LICENSE)
+
+## Authors
+
+Guillaume Leseur
+Robert Dober

data/lib/redis_cloud_auto_upgrade/configuration.rb

@@ -0,0 +1,51 @@
+# Configuration part
+class RedisCloudAutoUpgrade
+  Configuration = Struct.new(
+    :heroku_api_key,
+    :heroku_app_name,
+    :logger,
+    :on_upgrade,
+    :redis_instance,
+    :treshhold
+  ) do
+    attr_reader :errors
+
+    def configure(**values)
+      values.each do |key, val|
+        self[key] = val
+      end
+      self
+    end
+
+    def only(*keys)
+      keys.inject({})do |h, k|
+        h.merge(k => send(k))
+      end
+    end
+
+    def errors_human_readable
+      return nil if @errors.empty?
+      missing_fields
+    end
+
+    def valid?
+      heroku_api_key.nil? && @errors.push([:missing, :heroku_api_key])
+      heroku_app_name.nil? && @errors.push([:missing, :heroku_app_name])
+      @errors.empty?
+    end
+
+    private
+
+    def initialize
+      self[:treshhold] = 0.5
+      @errors = []
+    end
+
+    def missing_fields
+      mf = @errors
+           .select { |etype, _| etype == :missing }
+           .map { |_, message| message }
+      %(Missing required_fields: #{mf.inspect})
+    end
+  end
+end

data/lib/redis_cloud_auto_upgrade/exceptions.rb

@@ -0,0 +1,3 @@
+class RedisCloudAutoUpgrade
+  IllegalConfiguration = Class.new RuntimeError
+end # class RedisCloudAutoUpgrade

data/lib/redis_cloud_auto_upgrade/heroku_api.rb

@@ -0,0 +1,99 @@
+require 'platform-api'
+# A function wrapper accessing the Heroku Platform API in a functional way
+class RedisCloudAutoUpgrade
+  module HerokuAPI
+    class << self
+      def available_memory(plan)
+        plan_memory
+          .fetch(plan) do
+          fail ArgumentError, "the plan #{plan.inspect} does not exist"
+        end
+      end
+
+      def current_redis_cloud_plan(heroku_api_key:, heroku_app_name:)
+        heroku(heroku_api_key)
+          .addon
+          .list_by_app(heroku_app_name)
+          .find(&select_redis_cloud_addon)['plan']['name']
+      end
+
+      def currently_available_memory(heroku_api_key:, heroku_app_name:)
+        available_memory(
+          current_redis_cloud_plan(
+            heroku_api_key: heroku_api_key, heroku_app_name: heroku_app_name))
+      end
+
+      def next_plan_to_upgrade_to(heroku_api_key:, heroku_app_name:)
+        next_plan(
+          current_redis_cloud_plan(
+            heroku_api_key: heroku_api_key, heroku_app_name: heroku_app_name))
+      end
+
+      def upgrade_plan!(heroku_api_key:, heroku_app_name:)
+        next_plan =
+          next_plan_to_upgrade_to(heroku_api_key: heroku_api_key, heroku_app_name: heroku_app_name)
+        heroku(heroku_api_key)
+          .addon
+          .update(heroku_app_name, 'rediscloud', plan: next_plan)
+        next_plan
+      end
+
+      private
+
+      def heroku(api_key)
+        PlatformAPI.connect api_key
+      end
+
+      def next_plan(plan)
+        plan_transitions
+          .fetch(plan) do
+          fail ArgumentError, "the plan #{plan.inspect} does not exist or cannot be upgraded"
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def plan_transitions
+        {
+          'rediscloud:30' => 'rediscloud:100',
+          'rediscloud:100' => 'rediscloud:250',
+          'rediscloud:250' => 'rediscloud:500',
+          'rediscloud:500' => 'rediscloud:1_000',
+          'rediscloud:1_000' => 'rediscloud:2_500',
+          'rediscloud:2_500' => 'rediscloud:5_000',
+          'rediscloud:5_000' => 'rediscloud:10_000',
+          'rediscloud:10_000' => 'rediscloud:15_000',
+          'rediscloud:15_000' => 'rediscloud:20_000',
+          'rediscloud:20_000' => 'rediscloud:25_000',
+          'rediscloud:25_000' => 'rediscloud:50_000'
+        }
+      end
+
+      def plan_memory
+        {
+          'rediscloud:30' => 30_000_000,
+          'rediscloud:100' => 100_000_000,
+          'rediscloud:250' => 250_000_000,
+          'rediscloud:500' => 500_000_000,
+          'rediscloud:1000' => 1_000_000_000,
+          'rediscloud:2500' => 2_500_000_000,
+          'rediscloud:5000' => 5_000_000_000,
+          'rediscloud:10000' => 10_000_000_000,
+          'rediscloud:15000' => 15_000_000_000,
+          'rediscloud:20000' => 20_000_000_000,
+          'rediscloud:25000' => 25_000_000_000,
+          'rediscloud:50000' => 50_000_000_000
+        }
+      end
+
+      def select_redis_cloud_addon
+        lambda  do |addon|
+          begin
+            addon['addon_service']['name'] == 'rediscloud'
+          rescue
+            nil
+          end
+        end
+      end
+    end # class << self
+  end # module HerokuAPI
+end # class RCAU

data/lib/redis_cloud_auto_upgrade/version.rb

@@ -0,0 +1,3 @@
+class RedisCloudAutoUpgrade
+  VERSION = '0.2.2'
+end # class RedisCloudAutoUpgrade

data/lib/redis_cloud_auto_upgrade.rb

@@ -0,0 +1,121 @@
+require_relative './redis_cloud_auto_upgrade/version'
+require_relative './redis_cloud_auto_upgrade/exceptions'
+require_relative './redis_cloud_auto_upgrade/configuration'
+
+require_relative './redis_cloud_auto_upgrade/heroku_api'
+
+require 'redis'
+
+# See README.md for details
+class RedisCloudAutoUpgrade
+  class << self
+    def potential_upgrade!(conf, &blk)
+      updated_conf = conf.merge(on_upgrade: blk)
+      new
+        .configure(updated_conf)
+        .potential_upgrade!
+    end
+  end # class << self
+
+  def configure(config)
+    @config.configure config
+    self
+  end
+
+  def current_redis_cloud_plan
+    @__current_redis_cloud_plan ||=
+    HerokuAPI.current_redis_cloud_plan(**heroku_params)
+  end
+
+  # Memoize from lab42_core gem?
+  def current_redis_mem_usage
+    return @__current_redis_mem_usage__ if @__current_redis_mem_usage__
+    redis_instance = config.redis_instance || Redis.current
+    @__current_redis_mem_usage__ = redis_instance.info['used_memory'].to_i
+  end
+
+  def needs_to_upgrade?
+    !(current_redis_mem_usage <  currently_available_memory * config.treshhold)
+  end
+
+  def potential_upgrade!
+    if config.valid?
+      do_potential_upgrade!
+    else
+      fail IllegalConfiguration, config.errors_human_readable
+    end
+  end
+
+  private
+
+  def initialize
+    @config = Configuration.new
+  end
+
+  attr_reader :config
+
+  def currently_available_memory
+    @__currently_available_memory__ ||=
+      HerokuAPI.currently_available_memory(
+        **config.only(:heroku_api_key, :heroku_app_name))
+  end
+
+  def do_potential_upgrade!
+    if needs_to_upgrade?
+      do_upgrade!
+      true
+    else
+      info "no upgrade needed #{config.heroku_app_name} mem usage #{current_redis_mem_usage / 1_000_000}MB"
+      false
+    end
+  end
+
+  def do_upgrade!
+    old_plan = current_redis_cloud_plan
+    new_plan = HerokuAPI.upgrade_plan!(
+      **config.only(:heroku_api_key, :heroku_app_name)
+    )
+    log_upgrade old_plan, new_plan
+    config.on_upgrade.call(update_data(old_plan, new_plan)) if config.on_upgrade
+  end
+
+  def log_upgrade(old_plan, new_plan)
+    info <<-EOS
+upgraded RedisCloud plan for app: #{config.heroku_app_name}
+mem usage was approximately #{current_redis_mem_usage / 1_000_000}MB
+old_plan was #{old_plan}
+new_plan is #{new_plan}
+        EOS
+  end
+
+  def heroku_params
+    @__heroku_params__ ||=
+      config.only(:heroku_api_key, :heroku_app_name)
+  end
+
+  def info(str)
+    return unless config.logger
+    config.logger.info str
+  end
+
+  def mem_usage_in_percent
+    @__mem_usage_in_percent__ ||=
+      current_redis_mem_usage * 100 / currently_available_memory
+  end
+
+  def update_data(old_plan, new_plan)
+    OpenStruct.new(
+      old_plan: old_plan,
+      new_plan: new_plan,
+      upgraded_at: Time.now,
+      mem_usage: current_redis_mem_usage,
+      mem_usage_in_percent: mem_usage_in_percent,
+      treshhold_in_percent: treshhold_in_percent
+    )
+  end
+
+  def treshhold_in_percent
+    @__treshhold_in_percent__ ||=
+      ( config.treshhold * 100 ).round
+  end
+end # class RedisCloudAutoUpgrade

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: redis_cloud_auto_upgrade
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Robert Dober
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: platform-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.29.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.29.1
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+description: Gem permits to auto upgrade your Redis Cloud plan when a certain memory
+  usage treshold is reached
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/redis_cloud_auto_upgrade.rb
+- lib/redis_cloud_auto_upgrade/configuration.rb
+- lib/redis_cloud_auto_upgrade/exceptions.rb
+- lib/redis_cloud_auto_upgrade/heroku_api.rb
+- lib/redis_cloud_auto_upgrade/version.rb
+homepage: https://github.com/RobertDober/lab42_core
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Gem permits to auto upgrade your Redis Cloud plan when a certain memory usage
+  treshold is reached
+test_files: []