logstash-output-application_insights 0.1.3

data/lib/logstash/outputs/application_insights/client.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+# ----------------------------------------------------------------------------------
+# Logstash Output Application Insights
+#
+# Copyright (c) Microsoft Corporation
+#
+# All rights reserved. 
+#
+# Licensed under the Apache License, Version 2.0 (the License); 
+# you may not use this file except in compliance with the License. 
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 
+#
+# Unless required by applicable law or agreed to in writing, software 
+# distributed under the License is distributed on an "AS IS" BASIS, 
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#
+# See the Apache Version 2.0 License for specific language governing 
+# permissions and limitations under the License.
+# ----------------------------------------------------------------------------------
+
+class LogStash::Outputs::Application_insights
+  class Client
+
+    public
+
+    def initialize ( storage_account_name, force = nil )
+      @storage_account_name = storage_account_name
+      @storage_account = Clients.instance.active_storage_account( storage_account_name, force )
+
+      @tuple = @storage_account[:clients_Q].pop
+      ( @current_storage_account_key_index, @current_azure_storage_auth_sas, @current_azure_storage_client) = @tuple
+      if @current_storage_account_key_index != @storage_account[:valid_index]
+        @current_storage_account_key_index = @storage_account[:valid_index]
+        set_current_storage_account_client
+        @tuple = [ @current_storage_account_key_index, @current_azure_storage_auth_sas, @current_azure_storage_client ]
+      end 
+      @storage_account_key_index = @current_storage_account_key_index
+    end
+
+    def dispose ( io_failed_reason = nil )
+      if @tuple 
+        if  @current_storage_account_key_index == @storage_account_key_index
+          @storage_account[:clients_Q] << @tuple
+        else
+          @storage_account[:valid_index] = @current_storage_account_key_index
+          @storage_account[:clients_Q] << [ @current_storage_account_key_index, @current_azure_storage_auth_sas, @current_azure_storage_client ]
+        end
+        @tuple = nil
+
+        Clients.instance.failed_storage_account( @storage_account_name, io_failed_reason ) if io_failed_reason && :blobClient == @last_client_type
+      end
+      nil
+    end
+
+    def blobClient
+      raise UnexpectedBranchError, "client already disposed" unless @tuple
+      @last_client_type = :blobClient
+      @current_azure_storage_client.blobClient
+    end
+
+    def tableClient
+      raise UnexpectedBranchError, "client already disposed" unless @tuple
+      @last_client_type = :blobClient
+      @current_azure_storage_client.tableClient
+    end
+
+    def notifyClient
+      raise UnexpectedBranchError, "client already disposed" unless @tuple
+      @last_client_type = :notifyClient
+      @current_azure_storage_client
+    end
+
+    def storage_auth_sas
+      raise UnexpectedBranchError, "client already disposed" unless @tuple
+      @current_azure_storage_auth_sas
+    end
+
+
+    def switch_storage_account_key!
+      raise UnexpectedBranchError, "client already disposed" unless @tuple
+      @current_storage_account_key_index = ( @current_storage_account_key_index + 1 ) % @storage_account[:keys].length
+      if @current_storage_account_key_index == @storage_account_key_index
+        rollback_storage_account_key
+        false
+      else
+        set_current_storage_account_client
+        true
+      end
+    end
+
+    private
+
+    def rollback_storage_account_key
+      raise UnexpectedBranchError, "client already disposed" unless @tuple
+      ( @current_storage_account_key_index, @current_azure_storage_auth_sas, @current_azure_storage_client) = @tuple
+    end
+
+    def set_current_storage_account_client
+      configuration = Config.current
+      alt_storage_access_key = @storage_account[:keys][@current_storage_account_key_index]
+      options = { :storage_account_name => @storage_account_name, :storage_access_key => alt_storage_access_key }
+      options[:ca_file] = configuration[:ca_file] unless configuration[:ca_file].empty?
+      @current_azure_storage_client = Azure::Storage::Client.new( options )
+
+      @current_azure_storage_auth_sas = Azure::Storage::Auth::SharedAccessSignature.new( @storage_account_name, alt_storage_access_key )
+    end
+
+  end
+end

data/lib/logstash/outputs/application_insights/clients.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+# ----------------------------------------------------------------------------------
+# Logstash Output Application Insights
+#
+# Copyright (c) Microsoft Corporation
+#
+# All rights reserved. 
+#
+# Licensed under the Apache License, Version 2.0 (the License); 
+# you may not use this file except in compliance with the License. 
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 
+#
+# Unless required by applicable law or agreed to in writing, software 
+# distributed under the License is distributed on an "AS IS" BASIS, 
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#
+# See the Apache Version 2.0 License for specific language governing 
+# permissions and limitations under the License.
+# ----------------------------------------------------------------------------------
+
+class LogStash::Outputs::Application_insights
+  class Clients
+
+    public
+
+    def initialize
+      configuration = Config.current
+      @resurrect_delay = configuration[:resurrect_delay]
+      @storage_accounts = {  }
+      @storage_account_names = [  ]
+      @current_storage_account_names = [  ]
+      @last_storage_account_key_index = 0
+      @state_semaphore = Mutex.new
+      create_blob_clients( configuration )
+    end
+
+
+    def active_storage_account ( storage_account_name , force )
+      raise StorageAccountsOffError if 0 == @current_storage_account_names.length && force.nil?
+      @storage_accounts[storage_account_name]
+    end
+
+    def create_blob_clients ( configuration )
+      configuration[:storage_account_name_key].each do |storage_account_name, storage_account_keys|
+
+        clients_Q = Queue.new
+        @storage_accounts[storage_account_name] = { :keys => storage_account_keys, :clients_Q => clients_Q, :valid_index => 0, :state => :on, :off_reason => [] }
+        40.times do
+          # lazy creation, clients will be created when first needed
+          clients_Q << [ nil, nil, nil]
+        end
+        @storage_account_names << storage_account_name
+      end
+
+      @current_storage_account_names = @storage_account_names.clone
+    end
+
+
+    def storage_account_state_on? ( storage_account_name = nil )
+      if storage_account_name
+        @storage_accounts[storage_account_name][:off_reason].empty?
+      else
+        @current_storage_account_names.length > 0
+      end
+    end
+
+    def failed_storage_account( storage_account_name, io_failed_reason )
+      storage_account = @storage_accounts[storage_account_name]
+      @state_semaphore.synchronize {
+        unless storage_account[:off_reason].include?( io_failed_reason )
+          storage_account[:off_reason] << io_failed_reason
+          if storage_account[:off_reason].length == 1
+            current_storage_account_names = [  ]
+            @current_storage_account_names.each do |account_name|
+              current_storage_account_names << account_name unless account_name == storage_account_name
+            end
+            @current_storage_account_names = current_storage_account_names
+
+            Thread.new( storage_account_name ) do |account_name|
+              loop do
+                sleep( @resurrect_delay )
+                if Blob.new.test_storage( account_name )
+                  @state_semaphore.synchronize {
+                    storage_account = @storage_accounts[account_name]
+                    storage_account[:off_reason] = [  ]
+                    @current_storage_account_names << account_name
+                  }
+                  break
+                end
+              end
+            end
+
+          end
+        end
+      }
+    end
+
+    def get_random_active_storage( exclude )
+      @state_semaphore.synchronize { storage_account_name = ( @current_storage_account_names - exclude ).sample if @current_storage_account_names.length > 0 }
+    end
+
+    public
+
+    @@instance = Clients.new
+
+    def self.instance
+      @@instance
+    end
+
+    private_class_method :new
+  end
+end

data/lib/logstash/outputs/application_insights/config.rb

@@ -0,0 +1,341 @@
+# encoding: utf-8
+
+# ----------------------------------------------------------------------------------
+# Logstash Output Application Insights
+#
+# Copyright (c) Microsoft Corporation
+#
+# All rights reserved. 
+#
+# Licensed under the Apache License, Version 2.0 (the License); 
+# you may not use this file except in compliance with the License. 
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 
+#
+# Unless required by applicable law or agreed to in writing, software 
+# distributed under the License is distributed on an "AS IS" BASIS, 
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#
+# See the Apache Version 2.0 License for specific language governing 
+# permissions and limitations under the License.
+# ----------------------------------------------------------------------------------
+
+class LogStash::Outputs::Application_insights
+  class Config
+
+    public
+
+    @@configuration = {}
+
+    def self.current
+      @@configuration
+    end
+
+    def self.validate_and_adjust_configuration ( configuration )
+      configuration.each_pair { |config_name, config_value|
+        raise ConfigurationError, "#{config_name.to_s} must be defined" unless config_value || BOOLEAN_PROPERTIES.include?( config_name )
+        case config_name
+
+        when :logger_level
+          logger_level = validate_and_adjust( config_name, config_value, String )
+          raise ConfigurationError, "#{config_name.to_s} can be set to only one of the valid log levels" unless LOGGER_LEVEL_MAP[logger_level.upcase.to_sym]
+          configuration[config_name] = LOGGER_LEVEL_MAP[logger_level.upcase.to_sym]
+
+        when :logger_files
+          config_value = [ config_value ] if config_value.is_a?( String )
+          logger_files = validate_and_adjust( config_name, config_value, Array )
+
+          i = 0
+          logger_files.map! do |file_name|
+            file_name = validate_and_adjust( "#{config_name.to_s}[#{i}]", file_name, String )
+            i += 1
+            if "stdout" == file_name.downcase
+              file_name = :stdout
+              file = STDOUT
+            elsif "stderr" == file_name.downcase
+              file_name = :stderr
+              file = STDERR
+            else
+              file = ::File.open( file_name, "a+" )
+            end
+            [ file_name, file ]
+          end
+          configuration[config_name] = logger_files
+
+        when :logger_progname
+          configuration[config_name] = validate_and_adjust( config_name, config_value, String )
+
+        when :logger_shift_size
+          configuration[config_name] = validate_and_adjust_integer( config_name, config_value, MIN_LOGGER_SHIFT_SIZE, MAX_LOGGER_SHIFT_SIZE )
+
+        when :logger_shift_age
+          if config_value.is_a?( String )
+            config_value = validate_and_adjust( config_name, config_value, String ).downcase
+            raise ConfigurationError, "#{config_name.to_s} if string, can be set to only one of the following values: #{VALID_LOGGER_SHIFT_AGES}" unless VALID_LOGGER_SHIFT_AGES. include?( config_value )
+          elsif config_value.is_a?( Integer )
+            config_value = validate_and_adjust_integer( config_name, config_value, MIN_LOGGER_SHIFT_AGE, MAX_LOGGER_SHIFT_AGE )
+          else
+            raise ConfigurationError, "#{config_name.to_s} must be either a string or integer"
+          end
+          configuration[config_name] = config_value
+
+        when :azure_storage_container_prefix
+          azure_storage_container_prefix = validate_and_adjust( config_name, config_value, String )
+          unless azure_storage_container_prefix.empty?
+            len = 63 - "-#{AZURE_STORAGE_CONTAINER_LOGSTASH_PREFIX}-yyyy-mm-dd".length
+            validate_max( "azure_storage_container_prefix length", azure_storage_container_prefix.length, len )
+            azure_storage_container_prefix += "-"
+          end
+          azure_storage_container_prefix = azure_storage_container_prefix.downcase
+          container_name = "#{azure_storage_container_prefix}#{AZURE_STORAGE_CONTAINER_LOGSTASH_PREFIX}-yyyy-mm-dd"
+          raise ConfigurationError, "#{config_name.to_s} must have only alphanumeric and dash characters, cannot start or end with a dash, and a dash cannot follow a dash" unless Utils.valid_container_name?( container_name )
+          configuration[config_name] = azure_storage_container_prefix + AZURE_STORAGE_CONTAINER_LOGSTASH_PREFIX
+
+        when :azure_storage_azure_storage_table_prefix
+          azure_storage_table_prefix = validate_and_adjust( config_name, config_value, String )
+          unless azure_storage_table_prefix.empty?
+            len = 63 - "-#{AZURE_STORAGE_TABLE_LOGSTASH_PREFIX}yyyymmdd".length
+            validate_max( "azure_storage_table_prefix length", azure_storage_table_prefix.length, len )
+          end
+          table_name = "#{azure_storage_table_prefix}#{AZURE_STORAGE_TABLE_LOGSTASH_PREFIX}yyyymmdd"
+          raise ConfigurationError, "#{config_name} must have only alphanumeric" unless Utils.valid_table_name?( table_name )
+          configuration[config_name] = azure_storage_table_prefix + AZURE_STORAGE_TABLE_LOGSTASH_PREFIX
+
+        when :ca_file
+          config_value = validate_and_adjust( config_name, config_value, String )
+          unless config_value.empty?
+            raise ConfigurationError, "#{config_name} must have a valid path name" unless Utils.valid_file_path?( config_value )
+          end
+          configuration[config_name] = validate_and_adjust( config_name, config_value, String )
+
+        when :azure_storage_blob_prefix
+          azure_storage_blob_prefix = validate_and_adjust( config_name, config_value, String )
+          unless azure_storage_blob_prefix.empty?
+            len = 1024 - "-#{AZURE_STORAGE_BLOB_LOGSTASH_PREFIX}_ikey-#{INSTRUMENTATION_KEY_TEMPLATE}_table-#{TABLE_ID_TEMPLATE}_yyyy-mm-dd-HH-MM-SS-LLL".length
+            validate_max( "azure_storage_blob_prefix length", azure_storage_blob_prefix.length, len )
+            azure_storage_blob_prefix += "-"
+          end
+          azure_storage_blob_prefix += AZURE_STORAGE_BLOB_LOGSTASH_PREFIX
+
+          raise ConfigurationError, "#{config_name.to_s} doesn't meet url format" unless Utils.url?( "http://storage/container/#{azure_storage_blob_prefix}_ikey-#{INSTRUMENTATION_KEY_TEMPLATE}_table-#{TABLE_ID_TEMPLATE}.json" )
+          configuration[config_name] = azure_storage_blob_prefix
+
+        when :table_id
+          configuration[config_name] = validate_and_adjust_guid( config_name, config_value )
+
+        when :blob_max_bytesize
+         configuration[config_name] = validate_and_adjust_integer( config_name, config_value, MIN_BLOB_MAX_BYTESIZE, MAX_BLOB_MAX_BYTESIZE )
+
+        when :blob_max_events
+         configuration[config_name] = validate_and_adjust_integer( config_name, config_value, MIN_BLOB_MAX_EVENTS, MAX_BLOB_MAX_EVENTS )
+
+        when :blob_retention_time
+          configuration[config_name] = validate_and_adjust_number( config_name, config_value, MIN_BLOB_RETENTION_TIME, MAX_BLOB_RETENTION_TIME )
+
+        when :blob_access_expiry_time
+          configuration[config_name] = validate_and_adjust_number( config_name, config_value, MIN_BLOB_ACCESS_EXPIRY_TIME, MAX_BLOB_ACCESS_EXPIRY_TIME )
+
+        when :resurrect_delay
+          configuration[config_name] = validate_and_adjust_number( config_name, config_value, MIN_STORAGE_RESURRECT_DELAY, MAX_STORAGE_RESURRECT_DELAY )
+
+        when :flow_control_suspend_bytes
+          configuration[config_name] = validate_and_adjust_number( config_name, config_value, MIN_FLOW_CONTROL_SUSPEND_BYTES, MAX_FLOW_CONTROL_SUSPEND_BYTES )
+
+        when :flow_control_resume_bytes
+          configuration[config_name] = validate_and_adjust_number( config_name, config_value, MIN_FLOW_CONTROL_RESUME_BYTES, MAX_FLOW_CONTROL_RESUME_BYTES )
+
+        when :flow_control_delay
+          configuration[config_name] = validate_and_adjust_number( config_name, config_value, MIN_FLOW_CONTROL_DELAY, MAX_FLOW_CONTROL_DELAY )
+
+        when :io_retry_delay
+          configuration[config_name] = validate_and_adjust_number( config_name, config_value, MIN_IO_RETRY_DELAY, MAX_IO_RETRY_DELAY )
+
+        when :io_max_retries
+          configuration[config_name] = validate_and_adjust_integer( config_name, config_value, MIN_IO_MAX_RETRIES, MAX_IO_MAX_RETRIES )
+
+        when :storage_account_name_key
+          config_value = validate_and_adjust( config_name, config_value, Array )
+          if config_value.empty?
+            raise ConfigurationError, "#{config_name.to_s} is empty, at least one storage account name should be defined" unless ENV['AZURE_STORAGE_ACCOUNT']
+            raise ConfigurationError, "#{config_name.to_s} is empty, at least one storage account access key should be defined" unless ENV['AZURE_STORAGE_ACCESS_KEY']
+            config_value = [ ENV['AZURE_STORAGE_ACCOUNT'], ENV['AZURE_STORAGE_ACCESS_KEY'] ]
+          end
+
+          storage_account_name_key = validate_and_adjust( config_name, config_value, Array, :disallow_empty )
+          unless storage_account_name_key[0].is_a?( Array )
+            raise ConfigurationError, "#{config_name.to_s} property is empty, should contain at least one pair: account_name, key" unless 2 == storage_account_name_key.length
+            storage_account_name_key = [ [ storage_account_name_key[0], storage_account_name_key[1] ]]
+          end
+
+          index = 0
+          storage_account_name_key.map! { |pair|
+            pair = validate_and_adjust( "#{config_name.to_s}[#{index}]", pair, Array, :disallow_empty )
+            raise ConfigurationError, "#{config_name.to_s}[#{index}] must have two items" unless 2 == pair.length
+
+            ( name, keys ) = pair
+            name = validate_and_adjust( "#{config_name.to_s}[#{index}]:name", name, String, :disallow_empty )
+            raise ConfigurationError, "#{config_name.to_s}[#{index}]:name must between 3 to 24 characters" unless (name.length >= 3) && (name.length <= 24)
+            raise ConfigurationError, "##{config_name.to_s}[#{index}]:name bad format, must have only alphanumeric characters" unless Utils.alphanumeric?( name )
+
+            keys = [ keys ] if keys.is_a?( String )
+            keys = validate_and_adjust( "#{config_name}[#{index}]:keys", keys, Array, :disallow_empty )
+            keys.each_index do |i|
+              key = validate_and_adjust( "#{config_name}[#{index}:keys[#{i}]", keys[i], String, :disallow_empty )
+              raise ConfigurationError, "#{config_name}[#{index}:keys[#{i}] must have only valid base64 characters" unless Utils.base64?( key )
+            end
+            index += 1
+            [ name.downcase, keys ]
+          }
+          configuration[config_name] = storage_account_name_key
+
+        when :tables
+          tables = validate_and_adjust( config_name, config_value, Hash )
+          tables.each_pair { |table_id, properties|
+            table_id = validate_and_adjust_guid( "#{config_name}:table_id", table_id )
+            info = "#{config_name}[#{table_id}]"
+            properties = validate_and_adjust( info, properties, Hash )
+            properties = Utils.symbolize_hash_keys( properties )
+            validate_and_adjust_table_properties!( properties, configuration, info )
+            configuration[config_name][table_id] = properties
+          }
+        end
+      }
+      validate_and_adjust_table_properties!( configuration, configuration )
+      @@configuration = configuration
+    end
+
+
+    def self.symbolize_table_properties ( properties )
+      new_properties = {}
+      properties.each_pair { |property_name, property_value|
+        new_properties[property_name.to_sym] = property_value
+      }
+      new_properties
+    end
+
+    def self.validate_and_adjust_table_properties! ( properties, configuration, base_info = nil )
+
+      properties.each_pair { |property_name, property_value|
+        info = ( base_info.nil? ? "#{property_name}" : "#{base_info}[#{property_name}]" )
+        raise ConfigurationError, "#{info} must be defined" unless property_value || BOOLEAN_PROPERTIES.include?( property_name )
+
+        case property_name.downcase
+
+        when :intrumentation_key
+          properties[:intrumentation_key] = validate_and_adjust_guid( info, property_value )
+        when :blob_serialization
+          property_value = property_value.downcase
+          raise ConfigurationError, "#{info}, can be set to only one of the following values: #{VALID_EXT_EVENT_FORMAT}" unless VALID_EXT_EVENT_FORMAT.include?( property_value )
+          properties[:blob_serialization] = validate_and_adjust_ext( info ,property_value, configuration[:azure_storage_blob_prefix] ) # be careful depends on order
+        when :csv_default_value
+          properties[:csv_default_value] = validate_and_adjust( info, property_value, String )
+        when :csv_separator
+          properties[:csv_separator] = validate_and_adjust( info, property_value, String )
+        when :blob_max_delay
+          properties[:blob_max_delay] = validate_and_adjust_number( info, property_value, MIN_BLOB_MAX_DELAY, MAX_BLOB_MAX_DELAY )
+        when :event_separator
+          properties[:event_separator] = validate_and_adjust( info, property_value, String )
+        when :serialized_event_field
+          properties[:serialized_event_field] = ( property_value.nil? ? nil : validate_and_adjust( info, property_value, String ) )
+        when :case_insensitive_columns
+          properties[:case_insensitive_columns] = validate_and_adjust_boolean( info, property_value )
+        when :table_columns
+          if property_value.nil?
+            properties[:table_columns] = property_value
+          else
+            table_columns = property_value
+            table_columns = [ table_columns ] if table_columns.is_a?( String )
+            table_columns = validate_and_adjust( info, table_columns, Array)
+            new_table_columns = []
+            index = 0
+            table_columns.each do |column|
+              new_column = {}
+
+              column = { COLUMN_PROPERTY_NAME => column } if column.is_a?( String )
+              column = validate_and_adjust( "#{info}[#{index}]", column, Hash, :disallow_empty )
+              raise ConfigurationError, "#{info}[#{index}][#{COLUMN_PROPERTY_NAME}] must be defined" unless column[COLUMN_PROPERTY_NAME]
+              new_column[:name] = validate_and_adjust( "#{info}[#{index}][#{COLUMN_PROPERTY_NAME}]", column[COLUMN_PROPERTY_NAME], String )
+
+              if column[COLUMN_PROPERTY_DEFAULT]
+                new_column[:default] = validate_and_adjust( "#{info}[#{index}][#{COLUMN_PROPERTY_DEFAULT}]", column[COLUMN_PROPERTY_DEFAULT], String )
+              end
+
+              if column[COLUMN_PROPERTY_TYPE]
+                new_column[:type] = validate_and_adjust( "#{info}[#{index}][#{COLUMN_PROPERTY_TYPE}]", column[COLUMN_PROPERTY_TYPE], String ).downcase
+                raise ConfigurationError, "#{info}[#{index}][#{COLUMN_PROPERTY_TYPE}] can be only one of the following values: #{VALID_FIELDS_MAP_TYPES}" unless VALID_FIELDS_MAP_TYPES.any? {|type| type == new_column[:type]}
+                new_column[:type] = new_column[:type].to_sym
+              end
+              new_table_columns << new_column
+              index += 1
+            end
+            properties[:table_columns] = new_table_columns
+          end
+
+        else
+        end
+      }
+    end
+
+
+    private 
+
+    def self.validate_and_adjust_ext ( property, ext, prefix )
+      ext = validate_and_adjust( property, ext, String )
+      raise ConfigurationError, "#{property.to_s} must be a valid extension string, have only alphanumeric, dash and underline characters" unless Utils.ext?( ext )
+      len = 1024 - "#{prefix}-#{AZURE_STORAGE_BLOB_LOGSTASH_PREFIX}_ikey-#{INSTRUMENTATION_KEY_TEMPLATE}_table-#{TABLE_ID_TEMPLATE}_yyyy-mm-dd-HH-MM-SS-LLL".length
+      raise ConfigurationError, "#{property.to_s} length cannot be more than #{len} characters" unless ext.length <= len
+      ext
+    end
+
+    def self.validate_and_adjust ( property, value, type, disallow_empty = false )
+      raise ConfigurationError, "#{property.to_s} must be an #{type.to_s}" unless value.is_a?( type )
+      raise ConfigurationError, "#{property.to_s} cannot be empty" if disallow_empty && value.empty? 
+      return value unless String == type
+      Utils.unescape( value )
+    end
+
+    def self.validate_and_adjust_boolean( property, value )
+      raise ConfigurationError, "#{property.to_s} must be a Boolean" unless !!value == value
+      value
+    end
+
+
+    def self.validate_and_adjust_integer ( property, value, min, max )
+      if value.is_a?( String )
+        raise ConfigurationError, "#{property.to_s} must be an Integer or Integer string" unless Utils.integer?( value )
+        value = value.to_i
+      end
+      raise ConfigurationError, "#{property.to_s} must be an Integer" unless value.is_a?( Integer )
+      validate_max( property, value, max )
+      validate_min( property, value, min )
+      value
+    end
+
+    def self.validate_and_adjust_number ( property, value, min, max )
+      if value.is_a?( String )
+        raise ConfigurationError, "#{property.to_s} must be a number or number string" unless Utils.number?( value )
+        value = value.to_f
+      end
+      raise ConfigurationError, "#{property.to_s} must be an Integer" unless value.is_a?( Integer )
+      validate_max( property, value, max )
+      validate_min( property, value, min )
+      value
+    end
+
+    def self.validate_and_adjust_guid ( property, value )
+      value = validate_and_adjust( property, value, String )
+      raise ConfigurationError, "#{property.to_s} must be a Guid string, that followy this pattern xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" unless Utils.guid?( value )
+      value
+    end
+
+    def self.validate_max (property, value, max)
+      raise ConfigurationError, "#{property.to_s} cannot be bigger than #{max}" unless value <= max || 0 == max
+      value
+    end
+
+    def self.validate_min (property, value, min)
+      raise ConfigurationError, "#{property.to_s} cannot be less than #{min}" unless value >= min
+      value
+    end
+
+  end
+end