tingyun_rpm 1.0.6

data/lib/ting_yun/ting_yun_service/upload_service.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+require 'ting_yun/metrics/metric_spec'
+require 'ting_yun/metrics/metric_data'
+require 'ting_yun/support/serialize/encodes'
+
+module TingYun
+  class TingYunService
+    module UploadService
+
+      def compressed_json
+        TingYun::Support::Serialize::Encoders::CompressedJSON
+      end
+
+      def base64_compressed_json
+        TingYun::Support::Serialize::Encoders::Base64CompressedJSON
+      end
+
+      def json
+        TingYun::Support::Serialize::Encoders::Json
+      end
+
+      def metric_data(stats_hash)
+
+        timeslice_start = stats_hash.started_at
+        timeslice_end = stats_hash.harvested_at || Time.now
+
+        action_array, adpex_array, general_array, components_array, errors_array = build_metric_data_array(stats_hash)
+
+        upload_data = {
+            :type => 'perfMetrics',
+            :timeFrom => timeslice_start.to_i,
+            :timeTo => timeslice_end.to_i,
+            :interval => 60,
+            :actions => action_array,
+            :apdex => adpex_array,
+            :components => components_array,
+            :general => general_array,
+            :errors  => errors_array
+        }
+        result = invoke_remote(:upload, [upload_data])
+        fill_metric_id_cache(result)
+        result
+      end
+
+      # The collector wants to recieve metric data in a format that's different
+      # from how we store it inte -nally, so this method handles the translation.
+      # It also handles translating metric names to IDs using our metric ID cache.
+      def build_metric_data_array(stats_hash)
+        action_array = []
+        adpex_array = []
+        general_array = []
+        components_array = []
+        errors_array = []
+        stats_hash.each do |metric_spec, stats|
+
+          # Omit empty stats as an optimization
+          unless stats.is_reset?
+            metric_id = metric_id_cache[metric_spec.name]
+
+            if metric_spec.name.start_with?('WebAction')
+              action_array << TingYun::Metrics::MetricData.new(metric_spec, stats, metric_id)
+            elsif metric_spec.name.start_with?('Apdex')
+              adpex_array << TingYun::Metrics::MetricData.new(metric_spec, stats, metric_id)
+            elsif metric_spec.name.start_with?('Errors') && metric_spec.scope.empty?
+              errors_array << TingYun::Metrics::MetricData.new(metric_spec, stats, metric_id)
+            elsif metric_spec.name.start_with?('Database','View','MongoDB','Redis','Memcached','External','Nested', 'CPU', 'Memory', 'WebFrontend')
+              if metric_spec.scope.empty?
+                general_array << TingYun::Metrics::MetricData.new(metric_spec, stats, metric_id)
+              else
+                components_array << TingYun::Metrics::MetricData.new(metric_spec, stats, metric_id)
+              end
+            elsif metric_spec.name.start_with?('cross_app')
+              external =  metric_spec.name.split(';')
+              if metric_spec.scope.empty?
+                metric_spec.name = "ExternalTransaction/NULL/#{external[1]}"
+                general_array << TingYun::Metrics::MetricData.new(metric_spec, stats, metric_id)
+              else
+                metric_spec.name = "External/#{external[3]}"
+                metric_spec.calleeId = external[1]
+                metric_spec.calleeName = external[2]
+                components_array << TingYun::Metrics::MetricData.new(metric_spec, stats, metric_id)
+              end
+
+            end
+          end
+        end
+
+        [action_array, adpex_array, general_array, components_array, errors_array]
+      end
+
+
+      # takes an array of arrays of spec and id, adds it into the
+      # metric cache so we can save the collector some work by
+      # sending integers instead of strings the next time around
+      def fill_metric_id_cache(pairs_of_specs_and_ids)
+        pairs_of_specs_and_ids.each do |_, value|
+          if value.is_a? Array
+            value.each do |array|
+              if array.is_a? Array
+                metric_id_cache[array[0]["name"]] = array[1]
+              end
+            end
+          end
+        end
+      rescue => e
+        # If we've gotten this far, we don't want this error to propagate and
+        # make this post appear to have been non-successful, which would trigger
+        # re-aggregation of the same metric data into the next post, so just log
+        TingYun::Agent.logger.error("Failed to fill metric ID cache from response, error details follow ", e)
+      end
+    end
+
+    def error_data(unsent_errors)
+      upload_data = {
+          :type => 'errorTraceData',
+          :errors => unsent_errors
+      }
+      invoke_remote(:upload, [upload_data], :encoder=> json)
+    end
+
+
+    def action_trace_data(traces)
+      upload_data = {
+          :type => 'actionTraceData',
+          :actionTraces => traces
+      }
+      invoke_remote(:upload, [upload_data], :encoder=> json)
+    end
+
+
+    def sql_trace(sql_trace)
+      upload_data = {
+          :type => 'sqlTraceData',
+          :sqlTraces => sql_trace
+      }
+
+      invoke_remote(:upload, [upload_data], :encoder=> json)
+
+    end
+
+    def external_error_data(traces)
+      upload_data = {
+          :type => 'externalErrorTraceData',
+          :errors => traces
+      }
+      invoke_remote(:upload, [upload_data], :encoder=> json)
+    end
+  end
+end

data/lib/ting_yun/ting_yun_service.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+
+require 'ting_yun/agent'
+require 'zlib'
+require 'ting_yun/ting_yun_service/http'
+require 'ting_yun/support/collector'
+require 'ting_yun/support/serialize/encodes'
+require 'ting_yun/support/timer_lib'
+require 'ting_yun/support/exception'
+require 'ting_yun/support/serialize/json_marshaller'
+require 'ting_yun/ting_yun_service/upload_service'
+require 'ting_yun/version'
+
+module TingYun
+  class TingYunService
+    include Http
+    include UploadService
+
+    CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
+
+    PROTOCOL_VERSION = 1
+
+
+    attr_accessor :request_timeout,
+                  :appSessionKey,
+                  :data_version,
+                  :metric_id_cache,
+                  :applicationId,
+                  :ssl_cert_store,
+                  :shared_tcp_connection
+
+    def initialize(license_key=nil,collector=TingYun::Support.collector)
+
+      @license_key = license_key || TingYun::Agent.config[:'license_key']
+      @request_timeout = TingYun::Agent.config[:timeout]
+      @collector = collector
+      @data_version = TingYun::VERSION::STRING
+      @marshaller =TingYun::Support::Serialize::JsonMarshaller.new
+      @metric_id_cache = {}
+    end
+
+    def connect(settings={})
+      if host = get_redirect_host
+        @collector = TingYun::Support.collector_from_host(host)
+      end
+      response = invoke_remote(:initAgentApp, [settings])
+      TingYun::Agent.logger.info("initAgentApp response: #{response}") if TingYun::Agent.config[:'nbs.audit_mode']
+      @applicationId = response['applicationId']
+      @appSessionKey = response['appSessionKey']
+      response
+    end
+
+    def get_redirect_host
+      invoke_remote(:getRedirectHost)
+    end
+
+    def force_restart
+      @applicationId = nil
+      @appSessionKey = nil
+      @metric_id_cache = {}
+      close_shared_connection
+    end
+
+
+    # send a message via post to the actual server. This attempts
+    # to automatically compress the data via zlib if it is large
+    # enough to be worth compressing, and handles any errors the
+    # server may return
+
+    # private
+
+    def invoke_remote(method, payload=[], options = {})
+
+      data = nil
+      payload = payload[0]  if method == :initAgentApp
+      begin
+        data = @marshaller.dump(payload, options)
+      rescue StandardError, SystemStackError => e
+        handle_serialization_error(method, e)
+      end
+      # serialize_finish_time = Time.now
+
+      if TingYun::Agent.config[:'nbs.audit_mode']
+        TingYun::Agent.logger.info("the prepare data: #{data}")
+      else
+        TingYun::Agent.logger.info("prepare to send data")
+      end
+
+      data, encoding = compress_request_if_needed(data)
+      # size = data.size
+
+      uri = remote_method_uri(method)
+      full_uri = "#{@collector}#{uri}"
+      TingYun::Agent.logger.info("url: #{full_uri}") if TingYun::Agent.config[:'nbs.audit_mode']
+      response = send_request(:data      => data,
+                              :uri       => uri,
+                              :encoding  => encoding,
+                              :collector => @collector)
+
+      if TingYun::Agent.config[:'nbs.audit_mode']
+        TingYun::Agent.logger.info("the return data: #{response.body}")
+      else
+        TingYun::Agent.logger.info("the send-process end")
+      end
+      @marshaller.load(decompress_response(response))
+    end
+
+    def handle_serialization_error(method, e)
+      msg = "Failed to serialize #{method} data using #{@marshaller.class.to_s}: #{e.inspect}"
+      error = TingYun::Support::Exception::SerializationError.new(msg)
+      error.set_backtrace(e.backtrace)
+      raise error
+    end
+
+
+
+
+
+
+
+  end
+end

data/lib/ting_yun/version.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module VERSION
+
+    MAJOR = 1
+
+    MINOR = 0
+    TINY = 6
+
+
+
+    STRING = [MAJOR, MINOR, TINY].compact.join('.')
+
+  end
+end

data/lib/tingyun_rpm.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+# == TingYun  Initialization
+#
+# When installed as a gem, you can activate the Ting Yun agent one of the following ways:
+#
+# For Rails, add:
+#    config.gem 'tingyun_rpm'
+# to your initialization sequence.
+#
+# For merb, do
+#    dependency 'tingyun_rpm'
+# in the Merb config/init.rb
+#
+# For Sinatra, do
+#    require 'tingyun_rpm'
+# after requiring 'sinatra'.
+#
+# For other frameworks, or to manage the agent manually, invoke TingYun::Agent#manual_start
+# directly.
+#
+
+require 'ting_yun/frameworks'
+
+
+if defined?(Rails::VERSION)
+  if Rails::VERSION::MAJOR.to_i >= 3
+    module TingYun
+      class Railtie < Rails::Railtie
+
+        initializer "tingyun_rpm.start_plugin" do |app|
+          TingYun::Agent.logger.info('initialize tingyun_rpm start_plugin')
+          TingYun::Frameworks.init_start(:config => app.config)
+        end
+      end
+    end
+  else
+    # After version 2.0 of Rails we can access the configuration directly.
+    # We need it to add dev mode routes after initialization finished.
+    config = nil
+    config = Rails.configuration if Rails.respond_to?(:configuration)
+    TingYun::Frameworks.init_start(:config => config)
+  end
+else
+  TingYun::Frameworks.init_start
+end

data/tingyun_rpm.gemspec

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ting_yun/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'tingyun_rpm'
+  s.version  = TingYun::VERSION::STRING
+  s.author   = 'tingyun'
+  # s.email    = 'support@tingyun.com'
+  # s.homepage = 'http://tingyun.com/features/ruby.html'
+
+  s.licenses    = ['Tingyun', 'MIT', 'Ruby']
+  s.summary     = 'TingYun Ruby Agent'
+  # s.description = 'TingYun Ruby Agent. (http://tingyun.com/features/ruby.html)'
+
+  s.required_ruby_version     = '>= 1.8.7'
+  s.required_rubygems_version = '>= 1.3.5'
+
+  file_list = `git ls-files`.split
+  file_list.delete_if { |item| item =~ /(test\/|bin\/|Rakefile)/ }
+  s.files = file_list
+
+  s.require_paths = ['lib']
+  s.rubygems_version = Gem::VERSION
+
+  s.add_development_dependency 'rake', '10.1.0'
+  s.add_development_dependency 'minitest', '~> 4.7'
+  s.add_development_dependency 'minitest-ci', '= 2.4.0'
+  s.add_development_dependency 'minitest-focus', '~> 1.1'
+  s.add_development_dependency 'minitest-reporters', '0.14.24'
+  s.add_development_dependency 'simplecov', '= 0.10.0'
+  s.add_development_dependency 'mocha', '~> 0.13.0'
+  s.add_development_dependency 'rails', '~> 3.2'
+  s.add_development_dependency 'pry', '~> 0.9.12'
+  s.add_development_dependency 'hometown', '~> 0.2.5'
+  s.add_development_dependency 'yard'
+
+  if RUBY_VERSION >= '1.9.3'
+    s.add_development_dependency 'guard', '= 2.12.5'
+    s.add_development_dependency 'guard-minitest', '= 2.4.4'
+    s.add_development_dependency 'rb-fsevent', '= 0.9.4'
+  end
+
+  # compatible with Ruby 1.8.7
+  s.add_development_dependency 'i18n', '0.6.11'
+
+  if RUBY_PLATFORM == 'java'
+    s.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
+    s.add_development_dependency 'jruby-openssl'
+  else
+    s.add_development_dependency 'sqlite3', '= 1.3.10'
+  end
+
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    s.add_development_dependency 'rubysl'
+    s.add_development_dependency 'racc'
+  end
+end