tingyun_rpm 1.1.4.2 → 1.2.0

data/lib/ting_yun/agent/instance_methods/connect.rb

@@ -14,11 +14,12 @@ module TingYun
 
         include HandleErrors
 
-        # number of attempts we've made to contact the server
-        attr_accessor :connect_attempts
+
 
         # Disconnect just sets connected to false, which prevents
         # the agent from trying to connect again
+        # @connect_state has three state {:disconnected,:pending,:connected}
+
         def disconnect
           @connect_state = :disconnected
           true
@@ -39,17 +40,6 @@ module TingYun
           force || (!connected? && !disconnected?)
         end
 
-        # Retry period is a minute for each failed attempt that
-        # we've made. This should probably do some sort of sane TCP
-        # backoff to prevent hammering the server, but a minute for
-        # each attempt seems to work reasonably well.
-        def connect_retry_period
-          [600, connect_attempts * 60].min
-        end
-
-        def note_connect_failure
-          self.connect_attempts += 1
-        end
 
         def generate_environment_report
           @environment_report = environment_for_connect
@@ -114,17 +104,15 @@ module TingYun
         #   agent run and Ting Yun sees it as a separate instance (default is false).
         def catch_errors
           yield
-
-        rescue TingYun::Support::Exception::ExpiredConfigurationException => e
+        rescue  TingYun::Support::Exception::UnKnownServerException => e
           handle_force_restart(e)
           retry
-        rescue TingYun::Support::Exception::InvalidDataTokenException => e
-          handle_force_restart(e)
+        rescue TingYun::Support::Exception::ServerConnectionException => e
+          handle_delay_restart(e, 60)
           retry
-        rescue TingYun::Support::Exception::InvalidDataException => e
-          handle_server_error(e)
         rescue => e
-          handle_other_error(e)
+          handle_delay_restart(e, 60)
+          retry
         end
 
         # Takes a hash of configuration data returned from the

data/lib/ting_yun/agent/instance_methods/container_data_manager.rb

@@ -14,7 +14,7 @@ module TingYun
       module ContainerDataManager
 
 
-        attr_reader :stats_engine, :error_collector, :transaction_sampler, :sql_sampler, :middleware
+        attr_reader :stats_engine, :error_collector, :transaction_sampler, :sql_sampler
 
 
         def drop_buffered_data
@@ -34,7 +34,6 @@ module TingYun
           @error_collector = TingYun::Agent::Collector::ErrorCollector.new
           @transaction_sampler = TingYun::Agent::Collector::TransactionSampler.new
           @sql_sampler = TingYun::Agent::Collector::SqlSampler.new
-          @middleware = TingYun::Agent::Collector::MiddleWareCollector.new(@events)
         end
 
         def container_for_endpoint(endpoint)
@@ -106,7 +105,7 @@ module TingYun
         def harvest_from_container(container, endpoint)
           items =[]
           begin
-             if TingYun::Agent.config[:'nbs.agent_enabled']
+             if TingYun::Agent.config[:'enabled']
                items = container.harvest!
              else
                container.reset!

data/lib/ting_yun/agent/instance_methods/handle_errors.rb

@@ -53,8 +53,13 @@ module TingYun
           drop_buffered_data
           @service.force_restart if @service
           @connect_state = :pending
-          sleep 30
         end
+
+        def handle_delay_restart(error, sec)
+          handle_force_restart(error)
+          sleep sec
+        end
+
         def handle_force_disconnect(error)
           TingYun::Agent.logger.warn "Ting Yun forced this agent to disconnect (#{error.message})"
           disconnect

data/lib/ting_yun/agent/instance_methods/start.rb

@@ -11,8 +11,11 @@ module TingYun
 
         # Check to see if the agent should start, returning +true+ if it should.
         # should hava the vaild app_name, unstart-state and able to start
+        # The agent is disabled when it is not force enabled by the
+        # 'nbs.agent_enabled' option (e.g. in a manual start), or
+        # enabled normally through the configuration file
         def agent_should_start?
-          return false if already_started? || disabled?
+          return false if already_started? || !TingYun::Agent.config[:'nbs.agent_enabled']
           unless app_name_configured?
             TingYun::Agent.logger.error "No application name configured.",
                                "The Agent cannot start without at least one. Please check your ",
@@ -36,96 +39,30 @@ module TingYun
           end
         end
 
-        # The agent is disabled when it is not force enabled by the
-        # 'nbs.agent_enabled' option (e.g. in a manual start), or
-        # enabled normally through the configuration file
-        def disabled?
-          !TingYun::Agent.config[:'nbs.agent_enabled']
-        end
 
         def log_startup
-          log_environment
-          log_dispatcher
-          log_app_name
-        end
-
-        def log_environment
-          Agent.logger.info "Environment: #{::TingYun::Frameworks.framework.env}"
-        end
-
-        # Logs the dispatcher to the log file to assist with
-        # debugging. When no debugger is present, logs this fact to
-        # assist with proper dispatcher detection
-        def log_dispatcher
+          Agent.logger.info "Environment: #{::TingYun::Frameworks.framework.env}" # log_environment
           dispatcher_name = TingYun::Agent.config[:dispatcher].to_s
-
           if dispatcher_name.empty?
             TingYun::Agent.logger.info 'No known dispatcher detected.'
           else
             TingYun::Agent.logger.info "Dispatcher: #{dispatcher_name}"
-          end
-        end
-
-        def log_app_name
-          TingYun::Agent.logger.info "Application: #{TingYun::Agent.config.app_names.join(", ")}"
-        end
-
-        def sinatra_app?
-          (
-          defined?(Sinatra::Application) &&
-              Sinatra::Application.respond_to?(:run) &&
-              Sinatra::Application.run?
-          )
-        end
-
-        # Classy logging of the agent version and the current pid,
-        # so we can disambiguate processes in the log file and make
-        # sure they're running a reasonable version
-        def log_version_and_pid
-          TingYun::Agent.logger.debug "Ting Yun Ruby Agent #{TingYun::VERSION::STRING} Initialized: pid = #{$$}"
+          end # log_dispatcher
+          TingYun::Agent.logger.info "Application: #{TingYun::Agent.config.app_names.join(", ")}" # log_app_name
         end
 
-        # Warn the user if they have configured their agent not to
-        # send data, that way we can see this clearly in the log file
-        def monitoring?
-          if TingYun::Agent.config[:monitor_mode]
-            true
-          else
-            TingYun::Agent.logger.warn('Agent configured not to send data in this environment.')
-            false
-          end
-        end
 
-        # Tell the user when the license key is missing so they can
-        # fix it by adding it to the file
-        def has_license_key?
+        # A correct license key exists and is of the proper length
+        def has_correct_license_key?
           if TingYun::Agent.config[:license_key] && TingYun::Agent.config[:license_key].length > 0
             true
           else
             TingYun::Agent.logger.warn("No license key found. " +
-                                  "This often means your tingyun.yml file was not found, or it lacks a section for the running environment,'#{::TingYun::Frameworks.framework.env}'. You may also want to try linting your tingyun.yml to ensure it is valid YML.")
+                                           "This often means your tingyun.yml file was not found, or it lacks a section for the running environment,'#{::TingYun::Frameworks.framework.env}'. You may also want to try linting your tingyun.yml to ensure it is valid YML.")
             false
           end
         end
 
-        # A license key is an arbitrary 40 character string,
-        # usually looks something like a SHA1 hash
-        def correct_license_length
-          key = TingYun::Agent.config[:license_key]
-
-          if key.length > 0
-            true
-          else
-            TingYun::Agent.logger.error("Invalid license key: #{key}")
-            false
-          end
-        end
-
-        # A correct license key exists and is of the proper length
-        def has_correct_license_key?
-          has_license_key? && correct_license_length
-        end
-
         # Logs the configured application names
         def app_name_configured?
           names = TingYun::Agent.config.app_names
@@ -149,7 +86,7 @@ module TingYun
         # setting up the worker thread and the exit handler to shut
         # down the agent
         def check_config_and_start_agent
-          return unless monitoring? && has_correct_license_key?
+          return unless  has_correct_license_key?
           return if is_using_forking_dispatcher?
           setup_and_start_agent
         end
@@ -163,7 +100,7 @@ module TingYun
           @dispatcher.mark_started
           generate_environment_report
           install_exit_handler
-          cpu_and_memory
+          @middleware.load_samplers # cpu and memory load
 
           if TingYun::Agent.config[:sync_startup]
             connect_in_sync
@@ -199,9 +136,7 @@ module TingYun
           end
 
           return if !needs_restart ||
-              !Agent.config[:'nbs.agent_enabled'] ||
-              !Agent.config[:monitor_mode] ||
-              disconnected?
+              !Agent.config[:'nbs.agent_enabled'] || disconnected?
 
           ::TingYun::Agent.logger.debug "Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking."
 
@@ -212,9 +147,6 @@ module TingYun
           setup_and_start_agent(options)
         end
 
-        def cpu_and_memory
-          @middleware.load_samplers
-        end
 
       end
     end

data/lib/ting_yun/agent/transaction.rb

@@ -6,14 +6,24 @@ require 'ting_yun/agent/method_tracer_helpers'
 require 'ting_yun/agent/transaction/transaction_metrics'
 require 'ting_yun/agent/transaction/request_attributes'
 require 'ting_yun/agent/transaction/attributes'
+require 'ting_yun/agent/transaction/exceptions'
+require 'ting_yun/agent/transaction/apdex'
+require 'ting_yun/agent/transaction/class_method'
+require 'ting_yun/agent/transaction/instance_method'
 
 
 module TingYun
   module Agent
+    # web transaction
     class Transaction
 
+      include TingYun::Agent::Transaction::InstanceMethod
+
+      extend TingYun::Agent::Transaction::ClassMethod
+
+
+
 
-      APDEX_TXN_METRIC_PREFIX = 'Apdex/'.freeze
       SUBTRANSACTION_PREFIX = 'Nested/'.freeze
       CONTROLLER_PREFIX = 'WebAction/'.freeze
       RAKE_TRANSACTION_PREFIX     = 'BackgroundAction/Rake'.freeze
@@ -23,7 +33,7 @@ module TingYun
       MIDDLEWARE_PREFIX = 'Middleware/Rack/'.freeze
       GRAPE_PREFIX = 'Grape/'.freeze
       RAKE_PREFIX = 'Rake'.freeze
-      WEB_TRANSACTION_CATEGORIES = [:controller, :uri, :rack, :sinatra, :grape, :middleware, :thrift].freeze
+
       EMPTY_SUMMARY_METRICS = [].freeze
       MIDDLEWARE_SUMMARY_METRICS = ['Middleware/all'.freeze].freeze
 
@@ -32,43 +42,40 @@ module TingYun
       NESTED_TRACE_STOP_OPTIONS = {:metric => true}.freeze
 
 
-      # A Time instance for the start time, never nil
-      attr_accessor :start_time
-
 
       # A Time instance used for calculating the apdex score, which
       # might end up being @start, or it might be further upstream if
       # we can find a request header for the queue entry time
-      attr_accessor :apdex_start,
-                    :category,
-                    :frame_stack,
-                    :exceptions,
-                    :default_name,
-                    :metrics,
-                    :http_response_code,
-                    :response_content_type,
-                    :error_recorded,
-                    :guid,
-                    :attributes,
-                    :request_attributes
-
-
-      def initialize(category, options)
-        @guid = options[:client_transaction_id] || generate_guid
+
+
+      attr_reader :apdex,
+                  :exceptions,
+                  :metrics,
+                  :attributes,
+                  :request_attributes,
+                  :frame_stack,
+                  :guid,
+                  :category,
+                  :default_name,
+                  :start_time
+
+
+
+      def initialize(category, client_transaction_id, options)
+        @start_time = Time.now
+
+        @exceptions = TingYun::Agent::Transaction::Exceptions.new
+        @metrics = TingYun::Agent::TransactionMetrics.new
+        @attributes = TingYun::Agent::Transaction::Attributes.new
+        @apdex = TingYun::Agent::Transaction::Apdex.new(options[:apdex_start_time], @start_time)
+
         @has_children = false
         @category = category
-        @exceptions = {}
-        @start_time = Time.now
-        @apdex_start = options[:apdex_start_time] || @start_time
+
+        @guid = client_transaction_id || generate_guid
         @frame_stack = []
         @frozen_name = nil
         @default_name = TingYun::Helper.correctly_encoded(options[:transaction_name])
-        @metrics = TingYun::Agent::TransactionMetrics.new
-
-        @error_recorded = false
-
-        @attributes = TingYun::Agent::Transaction::Attributes.new
-
 
         if request = options[:request]
           @request_attributes = TingYun::Agent::Transaction::RequestAttributes.new request
@@ -77,7 +84,6 @@ module TingYun
         end
       end
 
-
       def request_path
         @request_attributes && @request_attributes.request_path
       end
@@ -86,116 +92,20 @@ module TingYun
         @request_attributes && @request_attributes.port
       end
 
-      def self.wrap(state, name, category, options = {})
-        Transaction.start(state, category, options.merge(:transaction_name => name))
-
-        begin
-          # We shouldn't raise from Transaction.start, but only wrap the yield
-          # to be absolutely sure we don't report agent problems as app errors
-          yield
-        rescue => e
-          Transaction.notice_error(e)
-          raise e
-        ensure
-          Transaction.stop(state)
-        end
-      end
-
-
-      def self.start(state, category, options)
-        category ||= :controller
-        txn = state.current_transaction
-        options[:client_transaction_id] = state.client_transaction_id
-        if txn
-          txn.create_nested_frame(state, category, options)
-        else
-          txn = start_new_transaction(state, category, options)
-        end
-
-        # merge params every step into here
-        txn.attributes.merge_request_parameters(options[:filtered_params])
-
-        txn
-      rescue => e
-        TingYun::Agent.logger.error("Exception during Transaction.start", e)
-      end
-
-      def self.start_new_transaction(state, category, options)
-        txn = Transaction.new(category, options)
-        state.reset(txn)
-        txn.start(state)
-        txn
-      end
 
       def start(state)
         return if !state.execution_traced?
+        ::TingYun::Agent.instance.events.notify(:start_transaction) # Dispatcher调用
+
+        ::TingYun::Agent::Collector::TransactionSampler.on_start_transaction(state, start_time)
+        ::TingYun::Agent::Collector::SqlSampler.on_start_transaction(state, request_path)
 
-        transaction_sampler.on_start_transaction(state, start_time)
-        sql_sampler.on_start_transaction(state, request_path)
-        TingYun::Agent.instance.events.notify(:start_transaction)
         frame_stack.push TingYun::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, Time.now.to_f)
         name_last_frame @default_name
         freeze_name_and_execute if @default_name.start_with?(RAKE_TRANSACTION_PREFIX)
       end
 
-      def create_nested_frame(state, category, options)
-        @has_children = true
-        frame_stack.push TingYun::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, Time.now.to_f)
-        name_last_frame(options[:transaction_name])
 
-        set_default_transaction_name(options[:transaction_name], category)
-      end
-
-
-      def set_default_transaction_name(name, category)
-        return log_frozen_name(name) if name_frozen?
-        if influences_transaction_name?(category)
-          self.default_name = name
-          @category = category if category
-        end
-      end
-
-
-      def self.stop(state, end_time = Time.now)
-
-        txn = state.current_transaction
-
-        if txn.nil?
-          TingYun::Agent.logger.error("Failed during Transaction.stop because there is no current transaction")
-          return
-        end
-
-        nested_frame = txn.frame_stack.pop
-
-        if txn.frame_stack.empty?
-          txn.stop(state, end_time, nested_frame)
-          state.reset
-        else
-          nested_name = nested_transaction_name(nested_frame.name)
-
-          if nested_name.start_with?(MIDDLEWARE_PREFIX)
-            summary_metrics = MIDDLEWARE_SUMMARY_METRICS
-          else
-            summary_metrics = EMPTY_SUMMARY_METRICS
-          end
-
-          TingYun::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
-              state,
-              nested_frame.start_time.to_f,
-              nested_name,
-              summary_metrics,
-              nested_frame,
-              NESTED_TRACE_STOP_OPTIONS,
-              end_time.to_f)
-
-        end
-
-        :transaction_stopped
-      rescue => e
-        state.reset
-        TingYun::Agent.logger.error("Exception during Transaction.stop", e)
-        nil
-      end
 
 
       def stop(state, end_time, outermost_frame)
@@ -210,7 +120,7 @@ module TingYun
           trace_options = TRACE_OPTIONS_UNSCOPED
         end
 
-        if needs_middleware_summary_metrics?(name)
+        if name.start_with?(MIDDLEWARE_PREFIX)
           summary_metrics_with_exclusive_time = MIDDLEWARE_SUMMARY_METRICS
         else
           summary_metrics_with_exclusive_time = EMPTY_SUMMARY_METRICS
@@ -226,280 +136,27 @@ module TingYun
             trace_options,
             end_time.to_f)
 
-        commit!(state, end_time, name) unless ignore(best_name)
+        commit(state, end_time, name) unless ignore(best_name)
       end
 
-      def self.nested_transaction_name(name)
-        if name.start_with?(CONTROLLER_PREFIX) || name.start_with?(RAKE_TRANSACTION_PREFIX)
-          "#{SUBTRANSACTION_PREFIX}#{name}"
-        else
-          name
-        end
-      end
 
-      def commit!(state, end_time, outermost_node_name)
+      def commit(state, end_time, outermost_node_name)
 
         assign_agent_attributes
 
 
-        transaction_sampler.on_finishing_transaction(state, self, end_time)
+        TingYun::Agent.instance.transaction_sampler.on_finishing_transaction(state, self, end_time)
 
-        sql_sampler.on_finishing_transaction(state, @frozen_name)
+        TingYun::Agent.instance.sql_sampler.on_finishing_transaction(state, @frozen_name)
 
         record_summary_metrics(outermost_node_name, end_time)
-        record_apdex(state, end_time)
-        record_exceptions
-        merge_metrics
-      end
-
-
-      def record_summary_metrics(outermost_node_name,end_time)
-        unless @frozen_name == outermost_node_name
-          @metrics.record_unscoped(@frozen_name, TingYun::Helper.time_to_millis(end_time.to_f - start_time.to_f))
-        end
-      end
-
-      def assign_agent_attributes
-
-        add_agent_attribute(:threadName,  "pid-#{$$}");
-
-        if http_response_code
-          add_agent_attribute(:httpStatus, http_response_code.to_s)
-        end
-
-        if response_content_type
-          add_agent_attribute(:contentType, response_content_type)
-        end
-
-
-        if @request_attributes
-          @request_attributes.assign_agent_attributes self
-        end
-
-      end
-
-      def add_agent_attribute(key, value)
-        @attributes.add_agent_attribute(key, value)
-      end
-
-      #collector error
-      def had_error?
-        if @exceptions.empty?
-          return false
-        else
-          return true
-        end
-      end
-
-      def record_exceptions
-        unless @exceptions.empty?
-          @exceptions.each do |exception, options|
-
-            options[:uri]      ||= request_path if request_path
-            options[:port]       = request_port if request_port
-            options[:metric_name]     = best_name
-            options[:attributes] = @attributes
-
-            @error_recorded = !!::TingYun::Agent.instance.error_collector.notice_error(exception, options) || @error_recorded
-          end
-        end
-      end
-
-      def record_apdex(state, end_time=Time.now)
-        total_duration = (end_time - apdex_start)*1000
-        if recording_web_transaction?
-          record_apdex_metrics(APDEX_TXN_METRIC_PREFIX, total_duration, apdex_t)
-        end
-      end
-
-
-      def record_apdex_metrics(transaction_prefix, total_duration, current_apdex_t)
-        return unless current_apdex_t
-        return unless @frozen_name.start_with?(CONTROLLER_PREFIX)
-
-        apdex_bucket_global = apdex_bucket(total_duration, current_apdex_t)
-        txn_apdex_metric = @frozen_name.sub(/^[^\/]+\//, transaction_prefix)
-        @metrics.record_unscoped(txn_apdex_metric, apdex_bucket_global, current_apdex_t)
-      end
-
-
-      def apdex_bucket(duration, current_apdex_t)
-        self.class.apdex_bucket(duration, had_error?, current_apdex_t)
-      end
-
-      def self.apdex_bucket(duration, failed, apdex_t)
-        case
-          when failed
-            :apdex_f
-          when duration <= apdex_t
-            :apdex_s
-          when duration <= 4 * apdex_t
-            :apdex_t
-          else
-            :apdex_f
-        end
-      end
-
-      def apdex_t
-        TingYun::Agent.config[:apdex_t]
-      end
-
-
-      # See TingYun::Agent.notice_error for options and commentary
-      def self.notice_error(e, options={})
-        state = TingYun::Agent::TransactionState.tl_get
-        txn = state.current_transaction
-        if txn
-          txn.notice_error(e, options)
-        elsif TingYun::Agent.instance
-          TingYun::Agent.instance.error_collector.notice_error(e, options)
-        end
-      end
-
-      # Do not call this.  Invoke the class method instead.
-      def notice_error(error, options={}) # :nodoc:
-        if @exceptions[error]
-          @exceptions[error].merge! options
-        else
-          @exceptions[error] = options
-        end
-      end
-
+        @apdex.record_apdex(@frozen_name, end_time, @exceptions.had_error?)
+        @exceptions.record_exceptions(@attributes)
 
-      # This transaction-local hash may be used as temprory storage by
-      # instrumentation that needs to pass data from one instrumentation point
-      # to another.
-      #
-      # For example, if both A and B are instrumented, and A calls B
-      # but some piece of state needed by the instrumentation at B is only
-      # available at A, the instrumentation at A may write into the hash, call
-      # through, and then remove the key afterwards, allowing the
-      # instrumentation at B to read the value in between.
-      #
-      # Keys should be symbols, and care should be taken to not generate key
-      # names dynamically, and to ensure that keys are removed upon return from
-      # the method that creates them.
-      #
-      def instrumentation_state
-        @instrumentation_state ||= {}
-      end
-
-      def with_database_metric_name(model, method, product=nil)
-        previous = self.instrumentation_state[:datastore_override]
-        model_name = case model
-                       when Class
-                         model.name
-                       when String
-                         model
-                       else
-                         model.to_s
-                     end
-        self.instrumentation_state[:datastore_override] = [method, model_name, product]
-        yield
-      ensure
-        self.instrumentation_state[:datastore_override] = previous
-      end
-
-      def freeze_name_and_execute
-        if !name_frozen?
-          @name_frozen = true
-          @frozen_name = best_name
-        end
 
-        yield if block_given?
-      end
-
-      def promoted_transaction_name(name)
-        if name.start_with?(MIDDLEWARE_PREFIX)
-          "#{CONTROLLER_PREFIX}#{name}"
-        else
-          name
-        end
-      end
-
-      def merge_metrics
         TingYun::Agent.instance.stats_engine.merge_transaction_metrics!(@metrics, best_name)
       end
 
-      def name_last_frame(name)
-        frame_stack.last.name = name
-      end
-
-      def name_frozen?
-        @frozen_name ? true : false
-      end
-
-      def log_frozen_name(name)
-        TingYun::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@frozen_name}'.")
-        nil
-      end
-
-      def influences_transaction_name?(category)
-        !category || frame_stack.size == 1 || similar_category?(category)
-      end
-
-      def web_category?(category)
-        WEB_TRANSACTION_CATEGORIES.include?(category)
-      end
-
-      def similar_category?(category)
-        web_category?(@category) == web_category?(category)
-      end
-
-      def recording_web_transaction?
-        web_category?(@category)
-      end
-
-      def self.recording_web_transaction? #THREAD_LOCAL_ACCESS
-        txn = tl_current
-        txn && txn.recording_web_transaction?
-      end
-
-      def self.tl_current
-        TingYun::Agent::TransactionState.tl_get.current_transaction
-      end
-
-      def needs_middleware_summary_metrics?(name)
-        name.start_with?(MIDDLEWARE_PREFIX)
-      end
-
-      alias_method :ignore, :needs_middleware_summary_metrics?
-
-      def best_name
-        @frozen_name || @default_name || ::TingYun::Agent::UNKNOWN_METRIC
-      end
-
-      def queue_time
-        @apdex_start ? @start_time - @apdex_start : 0
-      end
-
-
-      def agent
-        TingYun::Agent.instance
-      end
-
-      def sql_sampler
-        agent.sql_sampler
-      end
-
-
-      def transaction_sampler
-        TingYun::Agent.instance.transaction_sampler
-      end
-
-      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
-      GUID_LENGTH = 16
-
-      # generate a random 64 bit uuid
-      private
-      def generate_guid
-        guid = ''
-        GUID_LENGTH.times do
-          guid << HEX_DIGITS[rand(16)]
-        end
-        guid
-      end
-
     end
   end
 end