sc4ry 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19791a7d72756fe96464fd43fd648010a71ff7491b96702da23c8828c19f58a2
-  data.tar.gz: 6e1d7318a3de28fd0950213f9e8bf344819dc5858f66f5ce0ec5b1eb7275b99f
+  metadata.gz: f4cbfc8c2a7a821c3374916cdd69650a91f1eca5faa4dbbd93ac94e29dae5f89
+  data.tar.gz: dfa68d210342122e96e6f9fcd234fa73f6fefee667addac8371424b39c1b63d4
 SHA512:
-  metadata.gz: 7f2c87ddb8ee4dc04aa1d6b2b9b9f214309fc56749dbb85a648f541ca1c27621dffdfcb9619348c3cd57874f5f9e9f0c24371fc9926150d32bb62edf3d5e4798
-  data.tar.gz: b43b8a8a6611fa76c890b10ccc40ffbee0f035bf8af298891919dbb9b4bf3ece9fb1ef13fb5386f0807c11e188d6cf7e9448979a4dc3552a62d1043cf53c3a78
+  metadata.gz: 82590002c1ac457715776b0be304d77fa2903885cc4dc21ee45cea87ee070648661b48520453ab011cd287da49997990b4e607940a54954f5f82b5c884089715
+  data.tar.gz: 8b63d6b39cee270a1e1ab38ffcde491b746011126615bc4a5908b9f8790017f0c30c8899453ca1848ee4022f8528a0edd61587b583d58a8404e4eef139ecbb84

data/.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  container-job:
+    runs-on: ubuntu-latest
+    container: ruby:latest
+    services:
+      redis:
+        image: redis
+      pushgateway:
+        image: prom/pushgateway
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Run the default task
+      run: |
+        gem install bundler -v 2.2.3
+        bundle install
+        bundle exec rake
+      env:
+          # The hostname used to communicate with the Redis service container
+          REDIS_HOST: redis
+          REDIS_PORT: 6379
+          PROM_PG_PORT: 9091
+          PROM_PG_HOST: pushgateway

data/.gitignore

@@ -6,6 +6,6 @@
 /pkg/
 /spec/reports/
 /tmp/
-
+/yardoc/
 # rspec failure tracking
 .rspec_status

data/Gemfile

@@ -6,4 +6,7 @@ gemspec
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "prometheus-client", "~> 3.0"
-gem "rest-client", "~> 2.1"
+gem "rest-client", "~> 2.1"
+gem "redis", "~> 4.6"
+gem "version", "~> 1.1"
+

data/README.md

@@ -2,7 +2,25 @@
 
 Sc4ry provide the Circuit Breaker Design Pattern for your applications
 
-![Sc4ry logo](assets/images/logo_sc4ry.png) _Simple CircuitBreacker 4 RubY_
+[![Ruby](https://github.com/Ultragreen/Sc4ry/workflows/Ruby/badge.svg)](https://github.com/Ultragreen/sc4ry/actions?query=workflow%3ARuby+branch%3Amaster)
+![GitHub](https://img.shields.io/github/license/Ultragreen/sc4ry)
+
+[![Documentation](https://img.shields.io/badge/docs-rubydoc.info-brightgreen)](https://rubydoc.info/gems/sc4ry)
+![GitHub issues](https://img.shields.io/github/issues/Ultragreen/sc4ry)
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/Ultragreen/sc4ry)
+![GitHub top language](https://img.shields.io/github/languages/top/Ultragreen/sc4ry)
+![GitHub milestones](https://img.shields.io/github/milestones/open/Ultragreen/sc4ry)
+
+![Gem](https://img.shields.io/gem/dt/sc4ry)
+[![Gem Version](https://badge.fury.io/rb/sc4ry.svg)](https://badge.fury.io/rb/sc4ry)
+![Twitter Follow](https://img.shields.io/twitter/follow/Ultragreen?style=social)
+![GitHub Org's stars](https://img.shields.io/github/stars/Ultragreen?style=social)
+![GitHub watchers](https://img.shields.io/github/watchers/Ultragreen/sc4ry?style=social)
+
+<noscript><a href="https://liberapay.com/ruydiaz/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a></noscript>
+
+![Sc4ry logo](assets/images/logo_sc4ry.png) 
+_Simple CircuitBreacker 4 RubY_
 
 ## Installation
 
@@ -22,6 +40,9 @@ Or install it yourself as:
 
 ## Usage
 
+### Circuits States Worflow
+
+![Sc4ry workflow](assets/images/sc4ry_workflow.png) 
 ### sample with Restclient
 
 ```ruby
@@ -109,8 +130,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sc4ry. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/sc4ry/blob/master/CODE_OF_CONDUCT.md).
-
+Bug reports and pull requests are welcome on GitHub at https://github.com/Ultragreen/sc4ry. 
 
 ## License
 

data/Rakefile

@@ -1,6 +1,37 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require 'yard'
+require 'yard/rake/yardoc_task.rb'
+require 'code_statistics'
+require "roodi"
+require "roodi_task"
+require "version"
+require 'rake/version_task'
+Rake::VersionTask.new
+
+
+RoodiTask.new() do | t |
+  t.patterns = %w(lib/**/*.rb)
+  t.config = "ultragreen_roodi_coding_convention.yml"
+end
+
 
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+
+YARD::Rake::YardocTask.new do |t|
+    t.files   = [ 'lib/**/*.rb', '-', 'doc/**/*','spec/**/*_spec.rb']
+    t.options += ['-o', "yardoc"]
+end
+YARD::Config.load_plugin('yard-rspec')
+  
+namespace :yardoc do
+task :clobber do
+    rm_r "yardoc" rescue nil
+    rm_r ".yardoc" rescue nil
+    rm_r "pkg" rescue nil
+end
+end
+task :clobber => "yardoc:clobber"

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/sc4ry/backends/memory.rb

@@ -1,33 +1,60 @@
+# Sc4ry module
+# @note namespace
 module Sc4ry
+
+  # Sc4ry:Backends module
+  # @note namespace
   module Backends
 
+    # class of the memory backend
     class Memory
+              
+      # Constructor
+      # @param [Hash] config Config map 
+      # @return [Sc4ry::Backends::Memory] a in Memory backend
       def initialize(config=nil?)
         @data = Hash::new
       end
 
+      # return the list of find records in backend for a specific pattern
+      # @return [Array] list of record (for all hostname if hostname is specified)
       def list
         return @data.keys
       end
 
-      def get(options)
-        return @data[options[:key]]
+      # return value of queried record
+      # @param key [Symbol] the name of the record
+      # @return [String] content value of record
+      def get(key: )
+        return @data[key]
       end
 
-      def put(options)
-        @data[options[:key]] = options[:value]
+      # defined and store value for specified key
+      # @param key [Symbol] :key the name of the record
+      # @param value [Symbol] :value the content value of the record
+      # @return [String] content value of record
+      def put(key:, value: )
+        @data[key] = value
       end 
 
-      def del(options)
-        @data.delete options[:key]
+      # delete a specific record
+      # @param params [Symbol] the name of the record
+       # @return [Boolean] status of the operation
+      def del(key: )
+        @data.delete key
       end 
 
+      # flush all records in backend
+      # @return [Boolean] status of the operation
       def flush
         @data.clear
       end
 
-      def exist?(options)
-        return @data.include? options[:key]
+      # verifiy a specific record existence
+      # @param key [Symbol] the name of the record
+      # @return [Boolean] presence of the record
+      def exist?(key: )
+        return @data.include? key
       end
 
     end

data/lib/sc4ry/backends/redis.rb

@@ -16,46 +16,47 @@ module Sc4ry
         # return the list of find records in backend for a specific pattern
         # @return [Array] list of record (for all hostname if hostname is specified)
         def list
-           return @store.keys('*')
+           return @be.keys('*').map(&:to_sym)
         end
   
   
         # return value of queried record
-        # @param [Hash] options
-        # @option options [Symbol] :key the name of the record
+        # @param key [Symbol] the name of the record
         # @return [String] content value of record
-        def get(options)
-          return @store.get(options[:key])
+        def get(key:)
+          res = YAML.load(@be.get(key))
+          res[:exceptions].map! {|item|  item = Object.const_get(item) if item.class == String }
+          return res
         end
   
         # defined and store value for specified key
-        # @param [Hash] options
-        # @option options [Symbol] :key the name of the record
-        # @option options [Symbol] :value the content value of the record
+        # @param key [Symbol] :key the name of the record
+        # @param value [Symbol] :value the content value of the record
         # @return [String] content value of record
-        def put(options)
-          @store.set options[:key], options[:value]
+        def put(key: ,value:)
+          data = value.dup
+          data[:exceptions].map! {|item| item = item.name.to_s if item.class == Class }
+          @be.set key, data.to_yaml
         end
   
         # delete a specific record
-        # @param [Hash] options
-        # @option options [Symbol] :key the name of the record
+        # @param key [Symbol] the name of the record
         # @return [Boolean] status of the operation
-        def del(options)
-          @store.del options[:key]
+        def del(key: )
+          @be.del key
         end
   
         # flush all records in backend
+        # @return [Boolean] status of the operation
         def flush
-          @store.flushdb
+          @be.flushdb
         end
   
-        # verifiy a specific record existance
-        # @param [Hash] options
-        # @option options [Symbol] :key the name of the record
+        # verifiy a specific record existence
+        # @param key [Symbol] the name of the record
         # @return [Boolean] presence of the record
-        def exist?(options)
-          return ( not @store.get(options[:key]).nil?)
+        def exist?(key: )
+          return ( not @be.get(key).nil?)
         end
       
   

data/lib/sc4ry/circuits.rb

@@ -1,17 +1,56 @@
+# Sc4ry Module
+# @note namespace
 module Sc4ry
+  
+  # Circuits and default configuration management class
   class Circuits
 
     include Sc4ry::Constants
     include Sc4ry::Exceptions
 
     @@circuits_store = Sc4ry::Store.instance 
-
+    @@circuits_notifiers = Sc4ry::Notifiers
+    @@circuits_loggers = Sc4ry::Loggers
     @@config = DEFAULT_CONFIG
 
+    # @!group forwarders  
+
+    # Class method how forward the Notifiers class factory/manager
+    # @return [Sc4ry::Notifiers]
+    def Circuits.notifiers
+      return @@circuits_notifiers
+    end
+
+    # Class method how forward a Store manager class singleton
+    # @return [Sc4ry::Store]
+    def Circuits.store
+      return @@circuits_store
+    end
+
+    # Class method how forward the Logger manager class factory/manager
+    # @return [Sc4ry::Store]
+    def Circuits.loggers
+      return @@circuits_loggers
+    end
+
+
+
+    # @!endgroup
+
+
+    # @!group Default Sc4ry configuration management
+
+    # Class method how return de default Sc4ry config
+    # @return [Hash] 
     def Circuits.default_config
       return @@config
     end
 
+    # class method how merge a differential hash to default config
+    # @param [Hash] diff the differential hash config
+    # @example usage
+    #   include Sc4ry
+    #   Circuits.merge_default_config diff: {max_time: 20, notifiers: [:mattermost]}  
     def Circuits.merge_default_config(diff:)
       validator = Sc4ry::Config::Validator::new(definition: diff, from: @@config)
       validator.validate!
@@ -19,6 +58,13 @@ module Sc4ry
 
     end
 
+    # class method for specifiying config by block 
+    # @yield [Sc4ry::Config::ConfigMapper]
+    # @example usage
+    #   include Sc4ry
+    #   Circuits.configure do |spec|
+    #      spec.max_failure_count = 3 
+    #   end
     def Circuits.configure(&bloc)
       mapper = Sc4ry::Config::ConfigMapper::new(definition: @@config.dup)
       yield(mapper)
@@ -28,11 +74,33 @@ module Sc4ry
     end
 
 
+    # old default config setter 
+    # @deprecated use {.merge_default_config} instead
+    # @param [Hash] config
     def Circuits.default_config=(config)
       Sc4ry::Helpers.log level: :warn, message: "DEPRECATED: Circuits.default_config= is deprecated please use Circuits.merge_default_config add: {<config_hash>}"
       Circuits.merge_default_config(diff: config)
     end
 
+    # @!endgroup
+
+    # @!group Circuits management
+
+    # class method for registering a new circuit, cloud work with a block
+    # @yield [Sc4ry::Config::ConfigMapper]
+    # @param [Symbol] circuit a circuit name
+    # @param [Hash] config a config override on default config for the circuit
+    # @example usage
+    #   include Sc4ry 
+    #   Circuits.register circuit: :mycircuit, config: {raise_on_opening: true, timeout: true}
+    #   # or
+    #   Circuits.register circuit: :mycircuit do |spec|
+    #     spec.raise_on_opening = true
+    #     spec.timeout = true
+    #   end
+    # @return [Hash] the full config of the circuit after merge on default   
+    # @raise [Sc4ryGenericError] if use config keyword with a block
+    # @raise [Sc4ryGenericError] if circuit already exist in current store.
     def Circuits.register(circuit:, config: {})
       if config.size > 0 and block_given? then 
         raise Sc4ryGenericError, "config: keyword must not be defined when block is given"
@@ -46,51 +114,141 @@ module Sc4ry
       end
       validator.validate!
       Sc4ry::Helpers.log level: :debug, message: "Circuit #{circuit} : registered"
+      raise Sc4ryGenericError, "Circuit: #{circuit} already exist in store" if @@circuits_store.exist? key: circuit 
       @@circuits_store.put key: circuit, value: validator.result 
+      return validator.result
     end
 
+    # class method how list all circuits in current store
+    # @example usage
+    #   include Sc4ry 
+    #   circuits = Circuits.list
+    # @return [Array] the list of [Symbol] circuits name
     def Circuits.list
       return @@circuits_store.list
     end
 
+    # class method how flush all circuits in current store
+    # @example usage
+    #   include Sc4ry 
+    #   Circuits.flush
+    # @return [true,false] 
+    def Circuits.flush
+      return @@circuits_store.flush
+    end
 
-    def Circuits.get(options)
-      @@circuits_store.get key: options[:circuit]
+    # class method for unregistering a circuit
+    # @param [Symbol] circuit a circuit name
+    # @example usage
+    #   include Sc4ry 
+    #   Circuits.unregister circuit: :mycircuit
+    # @raise [Sc4ryGenericError] if circuit not found in current store.
+    # @return [true,false]
+    def Circuits.unregister(circuit:)
+      if Circuits.list.include? circuit then
+        @@circuits_store.del key: circuit
+        return true
+      else
+        raise Sc4ryGenericError, "Circuit #{circuit} not found"
+        return false
+      end
     end
 
-    def Circuits.run(options = {}, &block)
+
+    # class method for get a specific circuit by circuit name
+    # @param [Symbol] circuit a circuit name
+    # @example usage
+    #   include Sc4ry 
+    #   Circuits.get circuit: :mycircuit
+    # @return [Hash] the circuit record in current store included values and status if the circuit have already run.
+    def Circuits.get(circuit:)
+      @@circuits_store.get key: circuit
+    end
+
+    # class method for update the config of a specific circuit by circuit name
+    # @param [Symbol] circuit a circuit name
+    # @param [Hash] config a config hash to merge on current config
+    # @example usage
+    #   include Sc4ry 
+    #   Circuits.update_config circuit: :mycircuit, config: {}
+    # @note : <b>important</b> updating config will reset status and values ! 
+    # @return [Hash] new config for this circuit
+    def Circuits.update_config(circuit: , config: {forward_unknown_exceptions: false})
+      raise Sc4ryGenericError, "Circuit #{circuit} not found" unless Circuits.list.include? circuit
+      save = @@circuits_store.get key: circuit
+      save.delete_if {|key,val| [:status,:values].include? key}
+      Circuits.unregister(circuit: circuit)
+      save.merge! config
+      return Circuits.register circuit: circuit, config: save 
+    end
+
+    # class method for get the status of a specific circuit by circuit name
+    # @param [Symbol] circuit a circuit name
+    # @example usage
+    #   include Sc4ry 
+    #   Circuits.status circuit: :mycircuit
+    # @return [Symbol]  status must in [:open,:half_open,:closed,:never_run] 
+    def Circuits.status(circuit:)
+      data = @@circuits_store.get key: circuit
+      return (data.include? :status)? data[:status][:general] : :never_run
+    end
+
+
+    # class method for running circuit, need a block
+    # @yield [Proc]
+    # @param [Symbol] circuit a circuit name
+    # @example usage
+    #   include Sc4ry 
+    #   Circuits.run circuit: :mycircuit do 
+    #       #  [...]  your code like a Restclient.get("URL")
+    #   end
+    #   # or
+    #   Circuits.run do 
+    #        # [...] your code like a Restclient.get("URL")
+    #        #  running with the first define circuit (use only on a one circuit usage)
+    #   end
+    # @return [Hash] a result like ":general=>:open, :failure_count=>X, :overtime_count=>X, :timeout_count=>X"
+    # @raise [Sc4ryGenericError] if circuit already not exit, block is missing or store empty 
+    def Circuits.run(circuit: nil , &block)
       circuits_list = Circuits.list
       raise Sc4ryGenericError, "No circuit block given" unless block_given?
       raise Sc4ryGenericError, "No circuits defined" if circuits_list.empty? 
-      circuit_name = (options[:circuit])? options[:circuit] : circuits_list.first
+      circuit_name = (circuit)? circuit : circuits_list.first
       raise Sc4ryGenericError, "Circuit #{circuit_name} not found" unless circuits_list.include? circuit_name
-      circuit = Circuits.get circuit: circuit_name
+      circuit_to_run = Circuits.get circuit: circuit_name
       skip = false
-      if circuit.include? :status then
-        if circuit[:status][:general] == :open then 
+      if circuit_to_run.include? :status then
+        if circuit_to_run[:status][:general] == :open then 
           @now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          skip = true if ((@now - circuit[:values].last[:end_time]) <  circuit[:check_delay])
+          skip = true if ((@now - circuit_to_run[:values].last[:end_time]) <  circuit_to_run[:check_delay])
         end
       end
       unless skip 
-        controller = Sc4ry::RunController.new(circuit)
+        controller = Sc4ry::RunController.new(circuit_to_run)
         Circuits.control circuit: circuit_name, values: controller.run(block: block)
       end
-      Sc4ry::Helpers.log level: :debug, message: "Circuit #{circuit_name} : status #{circuit[:status]}"
-
+      result = @@circuits_store.get key: circuit_name
+      Sc4ry::Helpers.log level: :debug, message: "Circuit #{circuit_name} : status #{result[:status]}"
+      return result
     end
 
+    # @!endgroup
+
     private
-    def Circuits.control(options={})
-      data = @@circuits_store.get key: options[:circuit]
+    # the private class method to control circuits running status
+    # @param [Symbol] circuit the name the circuit to control
+    # @param [Hash] values the resut value of a run 
+    # @return [Boolean] 
+    def Circuits.control(circuit: , values: )
+      data = @@circuits_store.get key: circuit
       data[:status] = {:general => :closed, :failure_count => 0, :overtime_count => 0, :timeout_count => 0} unless data.include? :status
       data[:values] = Array::new unless data.include? :values
       level = [data[:max_failure_count].to_i, data[:max_timeout_count].to_i, data[:max_overtime_count].to_i].max
       data[:values].shift if data[:values].size > level
-      data[:values].push options[:values]
+      data[:values].push values
       worst_status = []
       ['failure','overtime','timeout'].each do |control|
-        if options[:values][control.to_sym] == true then
+        if values[control.to_sym] == true then
           data[:status]["#{control}_count".to_sym] += 1
         else
           data[:status]["#{control}_count".to_sym] = 0
@@ -111,11 +269,11 @@ module Sc4ry
       end
       if save != data[:status][:general] then
         raise CircuitBreaked if data[:status][:general] == :open and data[:raise_on_opening]
-        Sc4ry::Helpers.log level: :error, message: "Circuit #{options[:circuit]} : breacking ! " if data[:status][:general] == :open
-        Sc4ry::Helpers.log level: :info, message: "Circuit #{options[:circuit]} : is now closed" if data[:status][:general] == :closed
-        Sc4ry::Helpers.notify circuit: options[:circuit], config: data 
+        Sc4ry::Helpers.log level: :error, message: "Circuit #{circuit} : breacking ! " if data[:status][:general] == :open
+        Sc4ry::Helpers.log level: :info, message: "Circuit #{circuit} : is now closed" if data[:status][:general] == :closed
+        Sc4ry::Helpers.notify circuit: circuit, config: data 
       end          
-      @@circuits_store.put key: options[:circuit], value: data
+      @@circuits_store.put key: circuit, value: data
     end
   end
 end

data/lib/sc4ry/config.rb

@@ -1,32 +1,49 @@
+# Sc4ry module 
+# @note namespace
 module Sc4ry
+    # Sc4ry::Config module
+    # @note namespace
     module Config
+        # Configuration validator for Sc4ry default and circuits configuration
+        # @private
         class Validator
-            attr_reader :definition
-            attr_reader :default
+
+            # accessor on Circuit definition given for validation
+            attr_reader :input
+            # accessor on circuit initial definition from default config or given in construction by from keyword
+            # @note altered by reference to final result mapping with {#validate!}
+            attr_reader :config
             
             def result
-                @default
+                @config
             end
             
             include Sc4ry::Constants
             include Sc4ry::Exceptions
-            
+            # Validator constructor 
+            # @param [Hash] definition the config hash to merge and validate
+            # @param [Hash] from config hash merged on origin (default : the Sc4ry base config from Constants )
+            # @return [Validator] a new instance of Validator
             def initialize(definition: , from: DEFAULT_CONFIG)
-                @default = from
-                @definition = definition
+                @config = from
+                @input = definition
             end
             
+            # Validation method, alter by reference the config attribut
+            # @raise ConfigError if un unknown key is given in definition to merge. 
             def validate!
-                unknown_keys = @definition.keys.difference @default.keys
+                unknown_keys = @input.keys.difference @config.keys
                 raise ConfigError::new("Unknown keys in config set : #{unknown_keys.to_s}") unless unknown_keys.empty?
                 validate_formats
-                @default.merge! @definition 
+                @config.merge! @input 
                 format_exceptions
             end
             
             private
+            # Validation private sub method 
+            # @raise ConfigError if proposed values haven't the good format and deeply in array
             def validate_formats
-                definition.each do |spec,value|
+                @input.each do |spec,value|
                     raise ConfigError::new("#{spec} value #{DEFAULT_CONFIG_FORMATS[spec][:desc]}") unless DEFAULT_CONFIG_FORMATS[spec][:proc].call(value)
                     if DEFAULT_CONFIG_FORMATS[spec].include? :list then
                         value.each do |item|
@@ -36,17 +53,26 @@ module Sc4ry
                 end
             end
             
+            # adapter for exception key in config String to Constant Class Name if need
+            # @note by reference
             def format_exceptions
-                @default[:exceptions].map! {|item| item = (item.class == String)? Object.const_get(item) : item  }
+                @config[:exceptions].map! {|item| item = (item.class == String)? Object.const_get(item) : item  }
             end
             
         end
 
+        # Config Data mapper for block yielding methods for configuration 
+        # @note work for/with {Sc4ry::Circuits.configure} and {Sc4ry::Circuits.register} when block given
         class ConfigMapper
 
             include Sc4ry::Constants
+
+            # config from given definition passed in constructor
             attr_reader :config
             
+            # the mapping constructor from a given definition or the default From Sc4ry config (Constant)
+            # @param [Hash] definition a config hash 
+            # @note creating dynamically accessors on config record given in definition
             def initialize(definition: DEFAULT_CONFIG)
                 @config = definition
                 @config.each do |key,value|

data/lib/sc4ry/constants.rb

@@ -1,7 +1,14 @@
+# Sc4ry module
+# @note namespace
 module Sc4ry
+    # Sc4ry::Constants module
+    # @note namespace
     module Constants
 
+        # notifiers available in Sc4ry natively
         CURRENT_NOTIFIERS = [:prometheus, :mattermost]
+
+        # the Sc4ry default config entries and values
         DEFAULT_CONFIG = { 
             :max_failure_count => 5,
             :timeout_value => 20,
@@ -16,6 +23,7 @@ module Sc4ry
             :exceptions => [StandardError, RuntimeError]
             }
 
+        # Default config supported entries with format and Proc checker for {Sc4ry::Config::Validator}
         DEFAULT_CONFIG_FORMATS = { 
             :max_failure_count => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"}, 
             :timeout_value => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},