tingyun_rpm 1.0.6

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

@@ -0,0 +1,219 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/frameworks'
+require 'ting_yun/version'
+
+# before the real start,do check and log things
+module TingYun
+  module Agent
+    module InstanceMethods
+      module Start
+
+        # 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
+        def agent_should_start?
+          return false if already_started? || disabled?
+          unless app_name_configured?
+            TingYun::Agent.logger.error "No application name configured.",
+                               "The Agent cannot start without at least one. Please check your ",
+                               "tingyun.yml and ensure that it is valid and has at least one ",
+                               "value set for app_name in the",
+                               "environment."
+            return false
+          end
+          return true
+        end
+
+        def started?
+          @started
+        end
+
+        # Check whether we have already started, which is an error condition
+        def already_started?
+          if started?
+            TingYun::Agent.logger.info("Agent Started Already!")
+            true
+          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
+          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
+
+        # 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?
+          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.")
+            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
+          return names.respond_to?(:any?) && names.any?
+        end
+
+
+        # If we're using a dispatcher that forks before serving
+        # requests, we need to wait until the children are forked
+        # before connecting, otherwise the parent process sends useless data
+        def is_using_forking_dispatcher?
+          if [:puma, :passenger, :rainbows, :unicorn].include? TingYun::Agent.config[:dispatcher]
+            TingYun::Agent.logger.info "Deferring startup of agent reporting thread because #{TingYun::Agent.config[:dispatcher]} may fork."
+            true
+          else
+            false
+          end
+        end
+
+        # Sanity-check the agent configuration and start the agent,
+        # 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 if is_using_forking_dispatcher?
+          setup_and_start_agent
+        end
+
+        # This is the shared method between the main agent startup and the
+        # after_fork call restarting the thread in deferred dispatchers.
+        #
+        # Treatment of @started and env report is important to get right.
+        def setup_and_start_agent(options={})
+          @started = true
+          @dispatcher.mark_started
+          generate_environment_report
+          install_exit_handler
+          cpu_and_memory
+
+          start_worker_thread(options)
+
+        end
+
+        # This method should be called in a forked process after a fork.
+        # It assumes the parent process initialized the agent, but does
+        # not assume the agent started.
+        #
+        # The call is idempotent, but not re-entrant.
+        #
+        # * It clears any metrics carried over from the parent process
+        # * Restarts the sampler thread if necessary
+        # * Initiates a new agent run and worker loop unless that was done
+        #   in the parent process and +:force_reconnect+ is not true
+        #
+        # Options:
+        # * <tt>:force_reconnect => true</tt> to force the spawned process to
+        #   establish a new connection, such as when forking a long running process.
+        #   The default is false--it will only connect to the server if the parent
+        #   had not connected.
+        # * <tt>:keep_retrying => false</tt> if we try to initiate a new
+        #   connection, this tells me to only try it once so this method returns
+        #   quickly if there is some kind of latency with the server.
+        def after_fork(options={})
+          needs_restart = false
+          @after_fork_lock.synchronize do
+            needs_restart = @dispatcher.needs_restart?
+            @dispatcher.mark_started
+          end
+
+          return if !needs_restart ||
+              !Agent.config[:'nbs.agent_enabled'] ||
+              !Agent.config[:monitor_mode] ||
+              disconnected?
+
+          ::TingYun::Agent.logger.debug "Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking."
+
+          # Clear out locks and stats left over from parent process
+          reset_objects_with_locks
+          drop_buffered_data
+
+          setup_and_start_agent(options)
+        end
+
+        def cpu_and_memory
+          @middleware.load_samplers
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/agent/threading/agent_thread'
+require 'ting_yun/agent/event/event_loop'
+
+module TingYun
+  module Agent
+    module InstanceMethods
+      module StartWorkerThread
+        def  start_worker_thread(connection_options={})
+          TingYun::Agent.logger.debug "Creating Ruby Agent worker thread."
+          @worker_thread = TingYun::Agent::Threading::AgentThread.create('Worker Loop') do
+            deferred_work!(connection_options)
+          end
+        end
+
+        # This is the method that is run in a new thread in order to
+        # background the harvesting and sending of data during the
+        # normal operation of the agent.
+        #
+        # Takes connection options that determine how we should
+        # connect to the server, and loops endlessly - typically we
+        # never return from this method unless we're shutting down
+        # the agent
+        def deferred_work!(connection_options)
+          catch_errors do
+            TingYun::Agent.disable_all_tracing do
+              connect!(connection_options)
+              if connected?
+                create_and_run_event_loop
+              else
+                TingYun::Agent.logger.debug "No connection.  Worker thread ending."
+              end
+            end
+          end
+        end
+
+        def create_and_run_event_loop
+          @event_loop = TingYun::Agent::Event::EventLoop.new
+
+          @event_loop.on(:report_data) do
+            transmit_data
+          end
+          @event_loop.fire_every(Agent.config[:data_report_period], :report_data)
+
+          @event_loop.run
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/instance_methods.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/agent/instance_methods/start'
+require 'ting_yun/agent/instance_methods/connect'
+require 'ting_yun/agent/instance_methods/start_worker_thread'
+require 'ting_yun/agent/instance_methods/container_data_manager'
+
+module TingYun
+  module Agent
+    module InstanceMethods
+
+      include Start
+      include Connect
+      include ContainerDataManager
+      include StartWorkerThread
+
+
+
+      def reset_to_default_configuration
+        TingYun::Agent.config.remove_config_type(:manual)
+        TingYun::Agent.config.remove_config_type(:server)
+      end
+
+      def stop_event_loop
+        @event_loop.stop if @event_loop
+      end
+
+
+      def push_trace_execution_flag(flag =false)
+        TransactionState.tl_get.push_traced(flag)
+      end
+
+      def pop_trace_execution_flag
+        TransactionState.tl_get.pop_traced
+      end
+
+    end
+  end
+end

data/lib/ting_yun/agent/method_tracer.rb

@@ -0,0 +1,256 @@
+# encoding: utf-8
+
+# This file may be independently required to set up method tracing prior to
+# the full agent loading. In those cases, we do need at least this require to
+# bootstrap things.
+
+require 'ting_yun/frameworks' unless defined?(TingYun::Frameworks::Framework)
+require 'ting_yun/support/helper'
+require 'ting_yun/agent/method_tracer_helpers'
+
+module TingYun
+  module Agent
+
+    # This module contains class methods added to support installing custom
+    # metric tracers and executing for individual metrics.
+    #
+    # == Examples
+    #
+    # When the agent initializes, it extends Module with these methods.
+    # However if you want to use the API in code that might get loaded
+    # before the agent is initialized you will need to require
+    # this file:
+    #
+    #     require 'ting_yun/agent/method_tracer'
+    #     class A
+    #       include TingYun::Agent::MethodTracer
+    #       def process
+    #         ...
+    #       end
+    #       add_method_tracer :process
+    #     end
+    #
+    # To instrument a class method:
+    #
+    #     require 'ting_yun/agent/method_tracer'
+    #     class An
+    #       def self.process
+    #         ...
+    #       end
+    #       class << self
+    #         include TingYun::Agent::MethodTracer
+    #         add_method_tracer :process
+    #       end
+    #     end
+    #
+    # @api public
+    module MethodTracer
+
+      def self.included klass
+        klass.extend ClassMethods
+      end
+
+      def self.extended klass
+        klass.extend ClassMethods
+      end
+
+
+      def self.trace_execution_scoped(metric_names, options={}, callback = nil) #THREAD_LOCAL_ACCESS
+        TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metric_names, options, callback) do
+          # Using an implicit block avoids object allocation for a &block param
+          yield
+        end
+      end
+
+      # Defines methods used at the class level, for adding instrumentation
+      # @api public
+      module ClassMethods
+
+        # contains methods refactored out of the #add_method_tracer method
+        module AddMethodTracer
+          # Checks to see if the method we are attempting to trace
+          # actually exists or not. #add_method_tracer can't do
+          # anything if the method doesn't exist.
+          def _method_exists?(method_name)
+            exists = method_defined?(method_name) || private_method_defined?(method_name)
+            ::TingYun::Agent.logger.error("Did not trace #{self.name}##{method_name} because that method does not exist") unless exists
+            exists
+          end
+
+          # Default to the class where the method is defined.
+          #
+          # Example:
+          #  Foo.default_metric_name_code('bar') #=> "Custom/#{Foo.name}/bar"
+          def default_metric_name_code(method_name)
+            "Custom/#{self.name}/#{method_name.to_s}"
+          end
+
+          # Checks to see if we have already traced a method with a
+          # given metric by checking to see if the traced method
+          # exists. Warns the user if methods are being double-traced
+          # to help with debugging custom instrumentation.
+          def traced_method_exists?(method_name, metric_name_code)
+            exists = method_defined?(_traced_method_name(method_name, metric_name_code))
+            ::TingYun::Agent.logger.error("Attempt to trace a method twice with the same metric: Method = #{method_name}, Metric Name = #{metric_name_code}") if exists
+            exists
+          end
+
+          # Decides which code snippet we should be eval'ing in this
+          # context, based on the options.
+          def code_to_eval(method_name, metric_name_code, options)
+            options = validate_options(method_name, options)
+            if options[:push_scope]
+              method_with_push_scope(method_name, metric_name_code, options)
+            else
+              method_without_push_scope(method_name, metric_name_code, options)
+            end
+          end
+
+          # returns an eval-able string that contains the tracing code
+          # for a fully traced metric including scoping
+          def method_with_push_scope(method_name, metric_name_code, options)
+            "def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+              #{options[:code_header]}
+              result = ::TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(\"#{metric_name_code}\",
+                        :metric => #{options[:metric]}) do
+                #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)
+              end
+              #{options[:code_footer]}
+              result
+            end"
+          end
+
+          # returns an eval-able string that contains the traced
+          # method code used if the agent is not creating a scope for
+          # use in scoped metrics.
+          def method_without_push_scope(method_name, metric_name_code, options)
+            "def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+              #{assemble_code_header(method_name, metric_name_code, options)}
+              t0 = Time.now
+              begin
+                #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)\n
+              ensure
+                duration = (Time.now - t0).to_f
+                ::TingYun::Agent.record_metric(\"#{metric_name_code}\", duration)
+                #{options[:code_footer]}
+              end
+            end"
+          end
+
+          # Returns a code snippet to be eval'd that skips tracing
+          # when the agent is not tracing execution. turns
+          # instrumentation into effectively one method call overhead
+          # when the agent is disabled
+          def assemble_code_header(method_name, metric_name_code, options)
+            # header = "return #{_untraced_method_name(method_name, metric_name_code)}(*args, &block) unless TingYun::Agent.tl_is_execution_traced?\n"
+            header += options[:code_header].to_s
+            header
+          end
+
+
+
+        end
+        include AddMethodTracer
+
+
+        # Add a method tracer to the specified method.
+        #
+        # By default, this will cause invocations of the traced method to be
+        # recorded in transaction traces, and in a metric named after the class
+        # and method. It will also make the method show up in transaction-level
+        # breakdown charts and tables.
+        #
+        # === Overriding the metric name
+        #
+        # +metric_name_code+ is a string that is eval'd to get the name of the
+        # metric associated with the call, so if you want to use interpolation
+        # evaluated at call time, then single quote the value like this:
+        #
+        #     add_method_tracer :foo, 'Custom/#{self.class.name}/foo'
+        #
+        # This would name the metric according to the class of the runtime
+        # intance, as opposed to the class where +foo+ is defined.
+        #
+        # If not provided, the metric name will be <tt>Custom/ClassName/method_name</tt>.
+        #
+        # @param [Symbol] method_name the name of the method to trace
+        # @param [String] metric_name_code the metric name to record calls to
+        #   the traced method under. This may be either a static string, or Ruby
+        #   code to be evaluated at call-time in order to determine the metric
+        #   name dynamically.
+        # @param [Hash] options additional options controlling how the method is
+        #   traced.
+        # @option options [Boolean] :push_scope (true) If false, the traced method will
+        #   not appear in transaction traces or breakdown charts, and it will
+        #   only be visible in custom dashboards.
+        # @option options [Boolean] :metric (true) If false, the traced method will
+        #   only appear in transaction traces, but no metrics will be recorded
+        #   for it.
+        # @option options [String] :code_header ('') Ruby code to be inserted and run
+        #   before the tracer begins timing.
+        # @option options [String] :code_footer ('') Ruby code to be inserted and run
+        #   after the tracer stops timing.
+        #
+        # @example
+        #   add_method_tracer :foo
+        #
+        #   # With a custom metric name
+        #   add_method_tracer :foo, 'Custom/#{self.class.name}/foo'
+        #
+        #   # Instrument foo only for custom dashboards (not in transaction
+        #   # traces or breakdown charts)
+        #   add_method_tracer :foo, 'Custom/foo', :push_scope => false
+        #
+        #   # Instrument foo in transaction traces only
+        #   add_method_tracer :foo, 'Custom/foo', :metric => false
+        #
+        # @api public
+        #
+        def add_method_tracer(method_name, metric_name_code=nil, options = {})
+          return unless _method_exists?(method_name)
+          metric_name_code ||= default_metric_name_code(method_name)
+          return if traced_method_exists?(method_name, metric_name_code)
+
+          traced_method = code_to_eval(method_name, metric_name_code, options)
+
+          visibility = TingYun::Support::Helper.instance_method_visibility self, method_name
+
+          class_eval traced_method, __FILE__, __LINE__
+          alias_method _untraced_method_name(method_name, metric_name_code), method_name
+          alias_method method_name, _traced_method_name(method_name, metric_name_code)
+          send visibility, method_name
+          send visibility, _traced_method_name(method_name, metric_name_code)
+          ::TingYun::Agent.logger.debug("Traced method: class = #{self.name},"+
+                                             "method = #{method_name}, "+
+                                             "metric = '#{metric_name_code}'")
+        end
+
+        private
+
+        # given a method and a metric, this method returns the
+        # untraced alias of the method name
+        def _untraced_method_name(method_name, metric_name)
+          "#{_sanitize_name(method_name)}_without_trace_#{_sanitize_name(metric_name)}"
+        end
+
+        # given a method and a metric, this method returns the traced
+        # alias of the method name
+        def _traced_method_name(method_name, metric_name)
+          "#{_sanitize_name(method_name)}_with_trace_#{_sanitize_name(metric_name)}"
+        end
+
+        # makes sure that method names do not contain characters that
+        # might break the interpreter, for example ! or ? characters
+        # that are not allowed in the middle of method names
+        def _sanitize_name(name)
+          name.to_s.tr_s('^a-zA-Z0-9', '_')
+        end
+      end
+
+
+    end
+
+
+  end
+end
+

data/lib/ting_yun/agent/method_tracer_helpers.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+require 'ting_yun/agent'
+require 'ting_yun/agent/transaction/transaction_state'
+
+module TingYun
+  module Agent
+    module MethodTracerHelpers
+
+      extend self
+
+      def log_errors(code_area)
+        yield
+      rescue => e
+        ::TingYun::Agent.logger.error("Caught exception in #{code_area}.", e)
+        ::TingYun::Agent.notice_error(e, method: code_area, path: "ting_yun/agent/method_tracer_helpers")
+      end
+
+      def trace_execution_scoped_header(state, t0)
+        log_errors(:trace_execution_scoped_header) do
+          stack = state.traced_method_stack
+          stack.push_frame(state, :method_tracer, t0)
+        end
+      end
+
+      def trace_execution_scoped_footer(state, t0, first_name, metric_names, expected_frame, options, t1=Time.now.to_f)
+        log_errors(:trace_execution_scoped_footer) do
+          if expected_frame
+            stack = state.traced_method_stack
+            create_metrics = options.has_key?(:metric) ? options[:metric] : true
+            frame = stack.pop_frame(state, expected_frame, first_name, t1, create_metrics)
+
+            if create_metrics
+              duration = (t1 - t0)*1000
+              exclusive = duration - frame.children_time
+              if duration < 0
+                ::TingYun::Agent.logger.log_once(:warn, "metric_duration_negative:#{first_name}",
+                                                 "Metric #{first_name} has negative duration: #{duration} ms")
+              end
+              if exclusive < 0
+                ::TingYun::Agent.logger.log_once(:warn, "metric_exclusive_negative:#{first_name}",
+                                                 "Metric #{first_name} has negative exclusive time: duration = #{duration} ms, child_time = #{frame.children_time}")
+              end
+              record_metrics(state, first_name, metric_names, duration, exclusive, options)
+            end
+          end
+        end
+      end
+
+      def record_metrics(state, first_name, other_names, duration, exclusive, options)
+        record_scoped_metric = options.has_key?(:scoped_metric) ? options[:scoped_metric] : true
+        stat_engine = TingYun::Agent.instance.stats_engine
+        if record_scoped_metric
+          stat_engine.record_scoped_and_unscoped_metrics(state, first_name, other_names, duration, exclusive)
+        else
+          metrics = [first_name].concat(other_names)
+          stat_engine.record_unscoped_metrics(state, metrics, duration, exclusive)
+        end
+      end
+
+      def  trace_execution_scoped(metric_names, options={}, callback = nil) #THREAD_LOCAL_ACCESS
+        state = TingYun::Agent::TransactionState.tl_get
+
+        metric_names = Array(metric_names)
+        first_name   = metric_names.shift
+        return yield unless first_name
+
+        start_time = Time.now.to_f
+        expected_scope = trace_execution_scoped_header(state, start_time)
+
+        begin
+          yield
+        ensure
+          elapsed_time = (Time.now.to_f - start_time)
+          if callback
+            callback.call(elapsed_time)
+          end
+          trace_execution_scoped_footer(state, start_time, first_name, metric_names, expected_scope, options)
+        end
+      end
+
+
+
+    end
+  end
+end