tingyun_rpm 1.0.6

data/lib/ting_yun/logger/memory_logger.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+# Base class for startup logging and testing in multiverse
+require 'ting_yun/logger/log_once'
+
+module TingYun
+  module Logger
+    class MemoryLogger
+      include LogOnce
+
+      def initialize
+        @already_logged_lock = Mutex.new
+        clear_already_logged
+
+        @messages = []
+      end
+
+      def is_startup_logger?
+        true
+      end
+
+      attr_accessor :messages, :level, :log_formatter
+
+      def fatal(*msgs, &blk)
+        messages << [:fatal, msgs, blk]
+      end
+
+      def error(*msgs, &blk)
+        messages << [:error, msgs, blk]
+      end
+
+      def warn(*msgs, &blk)
+        messages << [:warn, msgs, blk]
+      end
+
+      def info(*msgs, &blk)
+        messages << [:info, msgs, blk]
+      end
+
+      def debug(*msgs, &blk)
+        messages << [:debug, msgs, blk]
+      end
+
+      def log_exception(level, e, backtrace_level=level)
+        messages << [:log_exception, [level, e, backtrace_level]]
+      end
+
+      def dump(logger)
+        messages.each do |(method, args, blk)|
+          logger.send(method, *args, &blk)
+        end
+        messages.clear
+      end
+    end
+  end
+end

data/lib/ting_yun/logger/null_logger.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module TingYun
+  module Logger
+    class NullLogger
+      def fatal(*args)
+        ;
+      end
+
+      def error(*args)
+        ;
+      end
+
+      def warn(*args)
+        ;
+      end
+
+      def info(*args)
+        ;
+      end
+
+      def debug(*args)
+        ;
+      end
+
+      def method_missing(method, *args, &blk)
+        nil
+      end
+    end
+  end
+end

data/lib/ting_yun/logger/startup_logger.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require 'ting_yun/logger/memory_logger'
+require 'singleton'
+
+module TingYun
+  module Logger
+    # In an effort to not lose messages during startup, we trap them in memory
+    # The real logger will then dump its contents out when it arrives.
+    class StartupLogger < MemoryLogger
+      include Singleton
+    end
+  end
+end

data/lib/ting_yun/logger.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Logger
+
+  end
+end

data/lib/ting_yun/metrics/metric_data.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'ting_yun/support/coerce'
+
+module TingYun
+  module Metrics
+    class MetricData
+
+      # nil, or a TingYun::Metrics::MetricSpec object if we have no cached ID
+      attr_reader :metric_spec
+      # nil or a cached integer ID for the metric from the collector.
+      attr_accessor :metric_id
+      # the actual statistics object
+      attr_accessor :stats
+
+      def initialize(metric_spec, stats, metric_id)
+        @metric_spec = metric_spec
+        self.stats = stats
+        self.metric_id = metric_id
+      end
+
+      def eql?(o)
+        (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+      end
+
+      def hash
+        metric_spec.hash ^ stats.hash
+      end
+
+      # Serialize with all attributes, but if the metric id is not nil, then don't send the metric spec
+      def to_json(*a)
+        %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
+      end
+
+      def to_s
+        if metric_spec
+          "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
+        else
+          "#{metric_id}: #{stats}"
+        end
+      end
+
+      def inspect
+        "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
+      end
+
+      include TingYun::Support::Coerce
+
+      def to_collector_array(encoder=nil)
+        stat_key = metric_id || stats_has_parent?
+        [ stat_key,metrics(stat_key)]
+      end
+
+      def stats_has_parent?
+        hash =  { 'name' => metric_spec.name }
+        hash['calleeId'] = metric_spec.calleeId unless metric_spec.calleeId.nil?
+        hash['calleeName'] = metric_spec.calleeName unless metric_spec.calleeName.nil?
+        unless metric_spec.scope.empty?
+          hash['parent'] = metric_spec.scope
+        end
+
+        return hash
+      end
+
+      def metrics(stat_key)
+
+        metrics = []
+
+        metrics << int(stats.call_count, stat_key)
+        if stats.max_call_time != 0.0 #apedx
+          metrics << float(stats.total_call_time.round, stat_key)
+          metrics << float(stats.total_exclusive_time.round, stat_key)
+          metrics << float(stats.max_call_time.round, stat_key)
+        end
+
+        if stats.min_call_time !=0.0 #
+          metrics << float(stats.min_call_time.round, stat_key)
+          metrics << float(stats.sum_of_squares.round, stat_key)
+        end
+
+        metrics
+      end
+    end
+  end
+end

data/lib/ting_yun/metrics/metric_spec.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+
+
+# this struct uniquely defines a metric, optionally inside
+# the call scope of another metric
+module TingYun
+  module Metrics
+    class MetricSpec
+      attr_accessor :name, :scope, :calleeId, :calleeName
+
+      # the maximum length of a metric name or metric scope
+      MAX_LENGTH = 255
+      LENGTH_RANGE = (0...MAX_LENGTH)
+      EMPTY_SCOPE = ''.freeze
+
+      def initialize(metric_name='', metric_scope=nil)
+        if metric_name.to_s.length > MAX_LENGTH
+          @name = metric_name.to_s[LENGTH_RANGE]
+        else
+          @name = metric_name.to_s
+        end
+
+        if metric_scope
+          if metric_scope.to_s.length > MAX_LENGTH
+            @scope = metric_scope.to_s[LENGTH_RANGE]
+          else
+            @scope = metric_scope.to_s
+          end
+        else
+          @scope = EMPTY_SCOPE
+        end
+      end
+
+      def ==(o)
+        self.eql?(o)
+      end
+
+      def eql? o
+        @name == o.name && @scope == o.scope
+      end
+
+      def hash
+        @name.hash ^ @scope.hash
+      end
+
+      # return a new metric spec if the given regex
+      # matches the name or scope.
+      def sub(pattern, replacement, apply_to_scope = true)
+        ::TingYun::Agent.logger.warn("The sub method on metric specs is deprecated") rescue nil
+        return nil if name !~ pattern &&
+            (!apply_to_scope || scope.nil? || scope !~ pattern)
+        new_name = name.sub(pattern, replacement)[LENGTH_RANGE]
+
+        if apply_to_scope
+          new_scope = (scope && scope.sub(pattern, replacement)[LENGTH_RANGE])
+        else
+          new_scope = scope
+        end
+
+        self.class.new new_name, new_scope
+      end
+
+      def to_s
+        return name if scope.empty?
+        "#{name}:#{scope}"
+      end
+
+      def inspect
+        "#<TingYun::Metrics::MetricSpec '#{name}':'#{scope}'>"
+      end
+
+      def to_json(*a)
+        {'name' => name,
+         'scope' => scope}.to_json(*a)
+      end
+
+      def <=>(o)
+        namecmp = self.name <=> o.name
+        return namecmp if namecmp != 0
+        return (self.scope || '') <=> (o.scope || '')
+      end
+
+
+
+    end
+  end
+end

data/lib/ting_yun/metrics/stats.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Metrics
+    class Stats
+      attr_accessor :call_count
+      attr_accessor :min_call_time
+      attr_accessor :max_call_time
+      attr_accessor :total_call_time
+      attr_accessor :total_exclusive_time
+      attr_accessor :sum_of_squares
+
+
+      def self.create_from_hash(hash_value)
+        stats = Stats.new
+        stats.call_count           = hash_value[:count] if hash_value[:count]
+        stats.total_call_time      = hash_value[:total] if hash_value[:total]
+        stats.total_exclusive_time = hash_value[:total] if hash_value[:total]
+        stats.min_call_time        = hash_value[:min] if hash_value[:min]
+        stats.max_call_time        = hash_value[:max] if hash_value[:max]
+        stats.sum_of_squares       = hash_value[:sum_of_squares] if hash_value[:sum_of_squares]
+        stats
+      end
+
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @call_count = 0
+        @total_call_time = 0.0
+        @total_exclusive_time = 0.0
+        @min_call_time = 0.0
+        @max_call_time = 0.0
+        @sum_of_squares = 0.0
+      end
+
+      alias_method :apdex_s, :call_count
+      alias_method :apdex_t, :total_call_time
+      alias_method :apdex_f, :total_exclusive_time
+
+
+      def is_reset?
+        call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
+      end
+
+      #self不变
+      def merge(other_stats)
+        stats = self.clone
+        stats.merge!(other_stats)
+      end
+
+      #self变化
+      def merge!(other)
+        @min_call_time = other.min_call_time if min_time_less?(other)
+        @max_call_time = other.max_call_time if max_time?(other)
+        @total_call_time += other.total_call_time
+        @total_exclusive_time += other.total_exclusive_time
+        @sum_of_squares += other.sum_of_squares
+        @call_count += other.call_count
+        self
+      end
+
+      def to_s
+        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s / #{'%.4f' % total_exclusive_time.to_f}s ex]"
+      end
+
+      def to_json(*_)
+        {
+            'call_count' => call_count.to_i,
+            'min_call_time' => min_call_time.to_f,
+            'max_call_time' => max_call_time.to_f,
+            'total_call_time' => total_call_time.to_f,
+            'total_exclusive_time' => total_exclusive_time.to_f,
+            'sum_of_squares' => sum_of_squares.to_f
+        }.to_json(*_)
+      end
+
+      def record(value=nil, aux=nil, &blk)
+        if blk
+          yield self
+        else
+          case value
+            when Numeric
+              aux ||= value
+              self.record_data_point(value, aux)
+            when :apdex_s, :apdex_t, :apdex_f
+              self.record_apdex(value, aux)
+            when TingYun::Metrics::Stats
+              self.merge!(value)
+          end
+        end
+      end
+
+      def record_apdex(bucket, apdex_t)
+        case bucket
+          when :apdex_s then @call_count += 1
+          when :apdex_t then @total_call_time += 1
+          when :apdex_f then @total_exclusive_time += 1
+        end
+        if apdex_t
+          @max_call_time = apdex_t
+        else
+          ::TingYun::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+        end
+      end
+
+
+
+      # record a single data point into the statistical gatherer.  The gatherer
+      # will aggregate all data points collected over a specified period and upload
+      # its data to the TingYun server
+      def record_data_point(value, exclusive_time = value)
+        @call_count += 1
+        @total_call_time += value
+        @min_call_time = value if value < @min_call_time || @call_count == 1
+        @max_call_time = value if value > @max_call_time
+        @total_exclusive_time += exclusive_time
+
+        @sum_of_squares += (value * value)
+        self
+      end
+
+      alias trace_call record_data_point
+
+      # increments the call_count by one
+      def increment_count(value = 1)
+        @call_count += value
+      end
+
+      def ==(other)
+        other.class == self.class &&
+            (
+            @min_call_time == other.min_call_time &&
+                @max_call_time == other.max_call_time &&
+                @total_call_time == other.total_call_time &&
+                @total_exclusive_time == other.total_exclusive_time &&
+                @sum_of_squares == other.sum_of_squares &&
+                @call_count == other.call_count
+            )
+      end
+
+
+      protected
+
+      def min_time_less?(other)
+        (other.min_call_time < min_call_time && other.call_count > 0) || call_count == 0
+      end
+
+      def max_time?(other)
+        other.max_call_time > max_call_time
+      end
+
+    end
+  end
+end

data/lib/ting_yun/metrics.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Metrics
+    CONTROLLER = "Controller"
+    DISPATCHER = "HttpDispatcher"
+    ACTIVE_RECORD = "ActiveRecord"
+    USER_TIME = "CPU/User Time"
+    MEMORY = "Memory/Physical"
+  end
+end

data/lib/ting_yun/support/coerce.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+require 'ting_yun/agent'
+
+module TingYun
+  module Support
+    # We really don't want to send bad values to the collector, and it doesn't
+    # accept types like Rational that have occasionally slipped into our data.
+    #
+    # These methods are intended to safely coerce things into the form we want,
+    # to provide documentation of expected types on to_collector_array methods,
+    # and to log failures if totally invalid data gets into outgoing data
+    module Coerce
+      module_function
+
+      def int(value, context=nil)
+        Integer(value)
+      rescue => error
+        log_failure(value, Integer, context, error)
+        0
+      end
+
+      def int_or_nil(value, context=nil)
+        return nil if value.nil?
+        Integer(value)
+      rescue => error
+        log_failure(value, Integer, context, error)
+        nil
+      end
+
+      def float(value, context=nil)
+        result = Float(value)
+        raise "Value #{result.inspect} is not finite." unless result.finite?
+        result
+      rescue => error
+        log_failure(value, Float, context, error)
+        0.0
+      end
+
+      def string(value, context=nil)
+        return value if value.nil?
+        String(value)
+      rescue => error
+        log_failure(value.class, String, context, error)
+        ""
+      end
+
+      # Convert a hash into a format acceptable to be included with Transaction
+      # event data.
+      #
+      # We accept a hash and will return a new hash where all of the keys
+      # have been converted to strings.  As values we only allow Strings,
+      # Floats, Integers. Symbols are also allowed but are converted to strings.
+      # Any values of other type (e.g. Hash, Array, any other class) are
+      # discarded. Their keys are also removed from the results hash.
+      def event_params(value, context=nil)
+        unless value.is_a? Hash
+          raise ArgumentError, "Expected Hash but got #{value.class}"
+        end
+        value.inject({}) do |memo, (key, val)|
+          case val
+            when String, Integer, TrueClass, FalseClass
+              memo[key.to_s] = val
+            when Float
+              if val.finite?
+                memo[key.to_s] = val
+              else
+                memo[key.to_s] = nil
+              end
+            when Symbol
+              memo[key.to_s] = val.to_s
+          end
+          memo
+        end
+      rescue => error
+        log_failure(value.class, 'valid event params', context, error)
+        {}
+      end
+
+      def log_failure(value, type, context, error)
+        msg = "Unable to convert '#{value}' to #{type}"
+        msg += " in context '#{context}'" if context
+        TingYun::Agent.logger.warn(msg, error)
+      end
+    end
+  end
+end

data/lib/ting_yun/support/collector.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'ting_yun/agent'
+
+module TingYun
+  module Support
+    class Collector <  Struct.new :name, :port
+      def to_s; "#{name}:#{port}"; end
+    end
+
+    module CollectorMethods
+      def collector
+        @remote_collector ||= collector_from_host
+      end
+
+      def api_collector
+        @api_collector ||= Collector.new(TingYun::Agent.config[:api_host], TingYun::Agent.config[:api_port])
+      end
+
+      def collector_from_host(hostname=nil)
+        Collector.new(hostname || TingYun::Agent.config[:host], TingYun::Agent.config[:port])
+      end
+
+    end
+
+    extend CollectorMethods
+
+  end
+end

data/lib/ting_yun/support/exception.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+#
+
+module TingYun
+  module Support
+    module Exception
+      # An exception that is thrown by the server if the agent license is invalid.
+      class LicenseException < StandardError;
+      end
+
+      # An exception that is thrown by the agent, if server['nbs.agent_enable']==false.
+      class AgentEnableException <StandardError;
+      end
+
+      # An exception that is thrown by the server, drop the data.
+      class UnKnownServerException < StandardError;
+      end
+
+      # An exception that forces an agent to stop reporting until its mongrel is restarted.
+      class ForceDisconnectException < StandardError;
+      end
+
+      # An exception that forces an agent to restart.
+      class ForceRestartException < StandardError;
+      end
+
+      # An exception that forces an agent to restart.
+      class InvalidDataException < StandardError;
+      end
+
+      class ExpiredConfigurationException < StandardError;
+      end
+
+      # An exception that forces an agent to restart initAgentApp.
+      class InvalidDataTokenException < StandardError;
+      end
+      # Used to blow out of a periodic task without logging a an error, such as for routine
+      # failures.
+      class ServerConnectionException < StandardError;
+      end
+
+      # When a post is either too large or poorly formatted we should
+      # drop it and not try to resend
+      class UnrecoverableServerException < ServerConnectionException;
+      end
+
+      # An unrecoverable client-side error that prevents the agent from continuing
+      class UnrecoverableAgentException < ServerConnectionException;
+      end
+
+      # An error while serializing data for the collector
+      class SerializationError < StandardError;
+      end
+
+      class BackgroundLoadingError < StandardError;
+      end
+
+      class UnsupportedMediaType < StandardError
+      end
+      # Used to wrap errors reported to agent by the collector
+      class CollectorError < StandardError;
+      end
+
+      #This is the base class for all errors that we want to record , It provides the
+      # standard support text at the front of the message, and is used for flagging
+      # agent errors when checking queue limits.
+      class InternalAgentError < StandardError
+        def initialize(msg=nil)
+          super("Ruby agent internal error. Please contact support referencing this error.\n #{msg}")
+        end
+      end
+
+      class InternalServerError < StandardError
+      end
+    end
+  end
+end

data/lib/ting_yun/support/hash_extensions.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Support
+    module HashExtensions
+      module_function
+
+      # recurses through hashes and arrays and stringifies keys
+      def stringify_keys_in_object(object)
+        case object
+          when Hash
+            object.inject({}) do |memo, (k, v)|
+              memo[k.to_s] = stringify_keys_in_object(v)
+              memo
+            end
+          when Array
+            object.map {|o| stringify_keys_in_object(o)}
+          else
+            object
+        end
+      end
+    end
+  end
+end