gcarerubymethodprofiler 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 902c21998bc34a46fe1c5afbce2bfedde2a5ae94
+  data.tar.gz: c328f9058a44d032e75da2b4f552eec15d6e2582
+SHA512:
+  metadata.gz: eee6483fcc6c9f262f2d4f58d7715d13487a1ccb62a6f356fe270c983d80c8ccd078b812b68952a719a4ca77e62505fe777b9fb3a34f37c46ff39132ca8ec5a5
+  data.tar.gz: c1b04b4705343e18a2c26269343cd71aa952869c7aa88284bde3ea72f3963f0bb172a35a48c6466d6b2c28506025bab131123b6d5e14ab7af5659c7eff85ea49

data/gcarerubymethodprofiler.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name = 'gcarerubymethodprofiler'
+  s.version = "1.0.0"
+  s.authors = ['Bipin V']
+  s.date = %q{2019-06-15}
+  s.summary = %q{generic method profiler for ruby}
+  s.description = 'Monitory ruby methods and send telemetry data to GCare Server'
+  s.authors     = ['Bipin V']
+  s.email       = ['bipin.v@gavstech.com']
+  s.homepage    = 'http://www.gavstech.com'
+  s.license     = 'Nonstandard'
+
+  s.files = Dir[
+    'README.md',
+    'Rakefile',
+    'lib/**/*.rb',
+    '*.gemspec',
+    'test/*.*'
+  ]
+  s.require_paths = ["lib"]
+end

data/lib/gcarerubymethodprofiler.rb

@@ -0,0 +1,330 @@
+require 'net/http'
+require 'json'
+require 'securerandom'
+require 'socket'
+require 'resolv'
+
+#https://pow.gs/mirror/discourse/blob/35d6fff69e86704081270333fbcb5248202a246a/lib/method_profiler.rb
+
+class GCareRubyMethodProfiler
+  def self.decorateHttp(methods, name, iKey, gcareurl, no_recurse: false)
+    patches = methods.map do |method_name|
+	recurse_protection = ""
+	  if no_recurse
+        recurse_protection = <<~RUBY
+          return #{method_name}__mp_unpatched(*args, &blk) if @mp_recurse_protect_#{method_name}
+          @mp_recurse_protect_#{method_name} = true
+        RUBY
+      end
+
+      <<~RUBY
+      unless defined?(#{method_name}__mp_unpatched)
+        alias_method :#{method_name}__mp_unpatched, :#{method_name}
+        def #{method_name}(*args, &blk)
+          unless prof = Thread.current[:_method_profiler]
+		  requestobject = nil
+		  donottrack = false
+		  gcare_telemetry_uri = URI("#{gcareurl}")
+		  case __method__.to_s
+			when 'request'
+				if args[0].is_a? Net::HTTPRequest
+				  requestobject = args[0]
+				  if requestobject.path == gcare_telemetry_uri.path
+					donottrack = true
+				  else
+				    donottrack = false
+				  end
+				end
+			when 'get'
+			  path =  args[0]
+			when 'get_response'
+			  uri_or_host = args[0]
+			  path  = args[1]
+			  port  = args[2]
+			when 'post'
+			  path =  args[0]
+			when 'post_form'
+			  uri_or_host = args[0]
+			when 'get2'
+			  path =  args[0]
+			when 'head2'
+			  path =  args[0]
+			when 'patch'
+			  path =  args[0]
+			when 'post2'
+			  path =  args[0]
+		  end
+		  gcareid = requestobject['GCareID']
+		  if gcareid == nil
+		    gcareid = SecureRandom.uuid
+			requestobject['GCareID'] = gcareid
+		  end
+
+          startTime = Time.now
+		  #{recurse_protection}
+		  returnvalue = #{method_name}__mp_unpatched(*args, &blk)
+		  if donottrack == false
+			donottrack = true
+            endTime = Time.now
+			timestamp = startTime.utc.iso8601(0)
+			scheme  = self.use_ssl? == true ? 'https' : 'http'
+			local_host = Socket.gethostname
+			local_ip = Resolv.getaddress(local_host)
+			remote_host = self.address
+			remote_ip = Resolv.getaddress(remote_host)
+			iKeyValue = "#{iKey}"
+			duration = Time.at(endTime - startTime).gmtime.strftime("00.%H:%M:%S.%7N")
+			teledata = {
+				'ver' => 2,
+				'name' => 'Gavs.ApplicationMonitoring.' + iKeyValue + '.RemoteDependency',
+				'time' => timestamp,
+				'sampleRate' => '100',
+				'iKey' => iKeyValue,
+				'tags' => {
+					'ai' => {
+						'internal.sdkVersion' => 'rb:1.0.0',
+						'operation.id' => nil,
+						'operation.name' => requestobject.method,
+						'gcare.id' => gcareid,
+						'device.roleInstance' => local_host
+					}
+				},
+				'data' => {
+				'baseType' => 'RemoteDependencyData',
+				'baseData' => {
+					'ver' => 2,
+					'platform_version' => "#{RUBY_VERSION}",
+					'platform_description' => 'ruby',
+					'id' => nil,
+					'GCareID' => gcareid,
+					'referer' => requestobject['referer'],
+					'scheme' =>  scheme,
+					'remote_ip' => local_ip,
+					'remote_host' => local_host,
+					'forwarding_ip' => nil,
+					'client_ip' => local_ip,
+					'server_host' => remote_host,
+					'server_ip' => remote_ip,
+					'server_hostname' => remote_host,
+					'useragent' => requestobject['user-agent'],
+					'session_id' =>  nil,
+					'timestamp' => timestamp,
+					'name' => requestobject.method,
+					'duration' => duration,
+					'responseCode' => returnvalue.code,
+					'success' => returnvalue.message,
+					'url' => returnvalue.uri == nil ? scheme + ":" + "//" + self.address + ":" + self.port.to_s + requestobject.path : returnvalue.uri,
+					'server_port' => self.port,
+					'properties' => {
+						'httpMethod' => requestobject.method
+					}
+				}
+			},
+			'machine' => {
+				'from_ip' => 'USER',
+				'from_name' => 'USER',
+				'to_ip' => remote_ip,
+				'to_name' => requestobject.path
+			}
+			}
+			puts teledata.to_json
+            
+			headers = {
+				'Accept' => 'application/json',
+				'Content-Type' => 'application/json; charset=utf-8'
+			}
+			request = Net::HTTP::Post.new(gcare_telemetry_uri.path, headers)
+			request.body = teledata.to_json
+			http = Net::HTTP.new gcare_telemetry_uri.hostname, gcare_telemetry_uri.port
+			if gcare_telemetry_uri.scheme.downcase == 'https'
+				http.use_ssl = true
+				http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			end
+			p "Sending RemoteDependency telemery data to GCare (http)"
+			response = http.request(request)
+
+			if !response.kind_of? Net::HTTPSuccess
+			end
+		  end
+		  if returnvalue.is_a?(Net::HTTPResponse)
+			  
+		  end
+		  if returnvalue.is_a?(String)
+			  
+		  end
+		  return returnvalue
+        end
+		#{recurse_protection}
+        begin
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+		  puts 'test2'
+		  puts args
+          #{method_name}__mp_unpatched(*args, &blk)
+        ensure
+          data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
+          data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+          data[:calls] += 1
+		  #{"@mp_recurse_protect_#{method_name} = false" if no_recurse}
+        end
+      end
+    end
+    RUBY
+    end.join("\n")
+	 Net::HTTP.class_eval patches
+  end
+
+  def format_request_duration(duration_seconds)
+	if duration_seconds >= 86400
+		# just return 1 day when it takes more than 1 day which should not happen for requests.
+		return "%02d.%02d:%02d:%02d.%07d" % [1, 0, 0, 0, 0]
+	end
+	Time.at(duration_seconds).gmtime.strftime("00.%H:%M:%S.%7N")
+  end
+
+    def self.decorateForOneArgument(klass, methods, name)
+    patches = methods.map do |method_name|
+      <<~RUBY
+      unless defined?(#{method_name}__mp_unpatched)
+        alias_method :#{method_name}__mp_unpatched, :#{method_name}
+        def #{method_name}(*args, &blk)
+          unless prof = Thread.current[:_method_profiler]
+			puts 'test1'
+            return #{method_name}__mp_unpatched(*args, &blk)
+          end
+          begin
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+			puts 'test2'
+			a = __method__.to_s
+			argsdata =  args.to_s
+			puts a
+			puts argsdata
+            #{method_name}__mp_unpatched(*args, &blk)
+          ensure
+            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
+            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            data[:calls] += 1
+          end
+        end
+      end
+      RUBY
+    end.join("\n")
+
+    klass.class_eval patches
+  end
+
+    def self.decorateSql(klass, methods, name)
+    patches = methods.map do |method_name|
+      <<~RUBY
+      unless defined?(#{method_name}__mp_unpatched)
+        alias_method :#{method_name}__mp_unpatched, :#{method_name}
+        def #{method_name}(*args, &blk)
+          unless prof = Thread.current[:_method_profiler]
+			puts 'test1'
+            return #{method_name}__mp_unpatched(*args, &blk)
+          end
+          begin
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+			puts 'test2'
+			puts args
+            #{method_name}__mp_unpatched(*args, &blk)
+          ensure
+            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
+            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            data[:calls] += 1
+          end
+        end
+      end
+      RUBY
+    end.join("\n")
+
+    klass.class_eval patches
+  end
+
+  def self.transfer
+    result = Thread.current[:_method_profiler]
+    Thread.current[:_method_profiler] = nil
+    result
+  end
+
+
+  def self.start
+    Thread.current[:_method_profiler] = transfer || {
+      __start: Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    }
+    puts "GCare Profiling Started"
+  end
+
+    def self.clear
+    Thread.current[:_method_profiler] = nil
+  end
+
+  def self.stop
+    finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    if data = Thread.current[:_method_profiler]
+      Thread.current[:_method_profiler] = nil
+      start = data.delete(:__start)
+      data[:total_duration] = finish - start
+      data
+    end
+    puts "GCare Profiling Stopped"
+  end
+
+  def telemetrydata(telemetryversion, name, time, sampleRate, iKey, sdkVersion,
+		operation_id, baseType, baseData_ver, baseData_id, gCareID,
+		remote_ip, remote_host, forwarding_ip, client_ip, server_host, server_ip, server_hostname,
+		useragent, session_id, timestamp, duration, responseCode, success,
+		url, httpMethod, version, machine_from_ip, machine_from_name, machine_to_ip,
+		machine_to_name, operation_name, roleInstance, server_port)
+
+		teledata = {
+			'ver' => telemetryversion,
+			'name' => name,
+			'time' => time,
+			'sampleRate' => sampleRate,
+			'iKey' => iKey,
+			'tags' => {
+				'ai' => {
+					'internal.sdkVersion' => sdkVersion,
+					'operation.id' => operation_id,
+					'operation.name' => operation_name,
+					'gcare.id' => gCareID,
+					'device.roleInstance' => roleInstance
+				}
+			}
+		}
+  end
+
+  def send(data_to_send)
+	uri = URI(@service_endpoint_uri)
+	headers = {
+		'Accept' => 'application/json',
+		'Content-Type' => 'application/json; charset=utf-8'
+	}
+	#,
+	#  'Content-Encoding' => 'gzip' # currently no encryption enabled
+	request = Net::HTTP::Post.new(uri.path, headers)
+
+	# Use JSON.generate instead of to_json, otherwise it will
+	# default to ActiveSupport::JSON.encode for Rails app
+	json = JSON.generate(data_to_send)
+	puts "sending data to CCare Server"
+	puts json
+	# compressed_data = compress(json)
+	request.body = json
+
+	http = Net::HTTP.new uri.hostname, uri.port #, 'localhost', 8888 # uncomment if proxy is used
+	if uri.scheme.downcase == 'https'
+		http.use_ssl = true
+		http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+	end
+
+	response = http.request(request)
+	http.finish if http.started?
+
+	if !response.kind_of? Net::HTTPSuccess
+		@logger.warn('application_insights') { "Failed to send data: #{response.message}" }
+	end
+
+  end
+end
+

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: gcarerubymethodprofiler
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bipin V
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-15 00:00:00.000000000 Z
+dependencies: []
+description: Monitory ruby methods and send telemetry data to GCare Server
+email:
+- bipin.v@gavstech.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- gcarerubymethodprofiler.gemspec
+- lib/gcarerubymethodprofiler.rb
+homepage: http://www.gavstech.com
+licenses:
+- Nonstandard
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.4
+signing_key: 
+specification_version: 4
+summary: generic method profiler for ruby
+test_files: []