atatus 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acfc54c3597def60fca53e99bf249711197735e0507b9bcade319f10182cbc26
-  data.tar.gz: efb49084366463b5ed40d3b4c57609ada57e745f28f8ac5949456e242167ede1
+  metadata.gz: 0ebfb72781685c274fbd7f4516df59c2ba5dc6533bc887dfbad3a3b6b93e08f6
+  data.tar.gz: 756f210e8bb7136aa87806fbdb3dcf1e1a9bd5986e8717322b26fba4148a9613
 SHA512:
-  metadata.gz: e6e2af0647be02da224d11dd9a45650c0c6cae63e10dbfaf81fd2d757fe8aa3414ab82ffad9eb880fc73f3340c145a175374be77a41f646febd621bf50502dca
-  data.tar.gz: 170206df98d5e3b5ccf68271f9dfdb58042ce45b13129321105aac2cf4fa8a04095807e0adc4ed75589bd09b556284ea41ac5a2030565584d96640da58aac03c
+  metadata.gz: 0a309c3b2ad681d3dc7a0a95b655e80ef0184a8b6522bf3f724b1266f65a0904e963043e21518711e3582d10757a7ab0c8c8550fd4df53d0a68442496291a352
+  data.tar.gz: 65c1dd53f5b6115b27edded97df2240af6e2d6217517fb59641792a60d185b6916a1bf442cb5fa277ece9711bca96a6a56acec0948edc7d6282ece771140c64e

data/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## 1.0.2 (Thu, 21 Nov 2019)
+
+- Changed Linux memory size to bytes.
+- Set type to agent name if framework is not deducted.
+- Code refactoring for checking existence of properties.
+
+
 ## 1.0.1 (Wed, 13 Nov 2019)
 
 - Fixed Instrumenting classes only when there are defined.

data/lib/atatus/collector/base.rb

@@ -1,81 +1,19 @@
+require 'json'
 require 'atatus'
-require 'atatus/transaction'
 require 'atatus/config'
-# require 'atatus/logger'
+require 'atatus/transaction'
+require 'atatus/collector/layer'
 require 'atatus/collector/transport'
-require 'json'
 
 module Atatus
   module Collector
-    class Layer
-      attr_reader :count, :min, :max, :total, :type, :kind, :id, :pid
-      attr_writer :id, :pid
-
-      def initialize(type, kind, duration)
-        @type = type
-        @kind = kind
-        @count = 1
-        @min = duration
-        @max = duration
-        @total = duration
-      end
-
-      def aggregate!(duration)
-        @count += 1
-        @min = duration if duration < @min
-        @max = duration if duration > @max
-        @total += duration
-      end
-
-      def self.span_kind(value)
-        return KINDS.fetch(value, value)
-      end
-
-      def self.span_type(value)
-        return TYPES.fetch(value, value)
-      end
-
-      private
-      KINDS = {
-        'db' => 'Database',
-        'cache' => 'Database',
-        'ext' => 'Remote',
-        'websocket' => 'Remote',
-        'template' => 'Template'
-      }.freeze
-
-      TYPES = {
-        'mysql' => 'MySQL',
-        'mysql2' => 'MySQL',
-        'postgresql' => 'Postgres',
-        'mssql' => 'MS SQL',
-        'mongodb' => 'MongoDB',
-        'redis' => 'Redis',
-        'graphql' => 'GraphQL',
-        'elasticsearch' => 'Elasticsearch',
-        'cassandra' => 'Cassandra',
-        'http' => 'External Requests',
-        'http2' => 'External Requests',
-        'http_rb' => 'External Requests',
-        'net_http' => 'External Requests'
-      }.freeze
-    end
-
     class Txn < Layer
-      attr_reader :spans
-
       def initialize(type, kind, duration)
         super(type, kind, duration)
-        @spans = Hash.new {}
+        @spans = {}
       end
 
-      def add_span(span_name, type, kind, duration)
-        if !@spans.has_key?(span_name)
-          @spans[key] = Layer.new(type, kind, duration)
-        else
-          @spans[key].aggregate! duration
-        end
-      end
+      attr_reader :spans
     end
 
     class Base
@@ -85,21 +23,22 @@ module Atatus
         # info 'Initializing Collector'
         @config = config
         @spans = Hash.new {|h,k| h[k]=[]}
-        @running = false
-        uri = URI("https://apm-rx.atatus.com/")
-        @transport = Atatus::BaseTransport.new(config, uri.host, uri.port)
-        @txn_lock = Mutex.new
-        @txn_aggs = Hash.new {}
-        @trace_aggs = Array.new()
-        @error_metrics = Hash.new {}
-        @error_requests = Array.new()
 
-        @error_lock = Mutex.new
-        @error_aggs = Array.new()
+        @txns_lock = Mutex.new
+        @txns_agg = {}
+        @traces_agg = []
+        @error_metrics_agg = {}
+        @error_requests_agg = []
+
+        @errors_lock = Mutex.new
+        @errors_aggs = []
 
         @metrics_lock = Mutex.new
-        @metrics = Array.new()
+        @metrics_agg = []
+
+        @transport = Atatus::BaseTransport.new(config)        
         @collect_counter = 0
+        @running = false
       end
 
       attr_reader :config
@@ -130,80 +69,113 @@ module Atatus
       def add_error(error)
         ensure_worker_running
 
-        @error_lock.synchronize do
-          if @error_aggs.length < 20
-            @error_aggs.push(error)
+        @errors_lock.synchronize do
+          if @errors_aggs.length < 20
+            @errors_aggs.push(error)
           else
             i = rand(20)
-            @error_aggs[i] = error
+            @errors_aggs[i] = error
           end
         end
-        # puts error.to_yaml
       end
 
       def add_metrics(metricset)
         ensure_worker_running
+        
+        metric_added = false
         metric = {}
-        if metricset.samples.key?(:'system.memory.total')
+
+        if %i[system.cpu.total.norm.pct system.memory.actual.free system.memory.total system.process.cpu.total.norm.pct system.process.memory.size system.process.memory.rss.bytes].all? {|s| metricset.samples.key? s}
+        then
           metric[:'system.cpu.total.norm.pct'] = metricset.samples[:'system.cpu.total.norm.pct']
           metric[:'system.memory.actual.free'] = metricset.samples[:'system.memory.actual.free']
           metric[:'system.memory.total'] = metricset.samples[:'system.memory.total']
           metric[:'system.process.cpu.total.norm.pct'] = metricset.samples[:'system.process.cpu.total.norm.pct']
           metric[:'system.process.memory.size'] = metricset.samples[:'system.process.memory.size']
           metric[:'system.process.memory.rss.bytes'] = metricset.samples[:'system.process.memory.rss.bytes']
+          metric_added = true
         end
 
-        if metricset.samples.key?(:'ruby.gc.count')
+        if %i[ruby.gc.count ruby.threads ruby.heaps.slots.live ruby.heap.slots.free ruby.heap.allocations.total].all? {|s| metricset.samples.key? s}
+        then
           metric[:'ruby.gc.count'] = metricset.samples[:'ruby.gc.count']
           metric[:'ruby.threads'] = metricset.samples[:'ruby.threads']
           metric[:'ruby.heap.slots.live'] = metricset.samples[:'ruby.heap.slots.live']
           metric[:'ruby.heap.slots.free'] = metricset.samples[:'ruby.heap.slots.free']
           metric[:'ruby.heap.allocations.total'] = metricset.samples[:'ruby.heap.allocations.total']
+          metric_added = true
         end
 
-        @metrics_lock.synchronize do
-          @metrics << metric
+        if metric_added
+          @metrics_lock.synchronize do
+            @metrics_agg << metric
+          end
         end
-        # puts metric.to_yaml
       end
 
       def add_span(span)
         ensure_worker_running
 
+        if
+          span.transaction_id.nil? ||  
+          span.name.nil? || 
+          span.type.nil? || 
+          span.subtype.nil? || 
+          span.duration.nil?
+        then
+          return
+        end
+
         @spans[span.transaction_id] << span if span.transaction_id
-        # puts span.to_yaml
       end
 
       def add_txn(txn)
         ensure_worker_running
 
-        # puts txn.to_yaml
-        txn_name = txn.name
-        return unless txn_name
-        @txn_lock.synchronize do
-          if !@txn_aggs.has_key?(txn_name)
-            @txn_aggs[txn_name] = Txn.new(@config.framework_name, "Ruby", txn.duration)
-            @txn_aggs[txn_name].id = txn.id
-            @txn_aggs[txn_name].pid = txn.id
+        if 
+          txn.name.nil? || 
+          txn.id.nil? || 
+          txn.duration.nil?
+        then
+          return
+        end
+
+        return if txn.name.empty?
+
+        @txns_lock.synchronize do
+          if !@txns_agg.key?(txn.name)
+            @txns_agg[txn.name] = Txn.new(@config.framework_name, "Ruby", txn.duration)
+            @txns_agg[txn.name].id = txn.id
+            @txns_agg[txn.name].pid = txn.id
           else
-            @txn_aggs[txn_name].aggregate! txn.duration
+            @txns_agg[txn.name].aggregate! txn.duration
           end
 
           spans_present = false
-          if @spans.has_key?(txn.id)
+          if @spans.key?(txn.id)
             @spans[txn.id].each do |span|
-              span_name = span.name
-              if !@txn_aggs[txn_name].spans.has_key?(span_name)
+              if 
+                span.name.nil? || 
+                span.type.nil? || 
+                span.subtype.nil? || 
+                span.duration.nil?
+              then
+                next
+              end
+
+              next if span.name.empty?
+
+              if !@txns_agg[txn.name].spans.key?(span.name)
                 kind = Layer.span_kind(span.type)
                 type = Layer.span_type(span.subtype)
-                @txn_aggs[txn_name].spans[span_name] = Layer.new(type, kind, span.duration)
-                @txn_aggs[txn_name].spans[span_name].id = span.id
-                @txn_aggs[txn_name].spans[span_name].pid = span.transaction_id
+                @txns_agg[txn.name].spans[span.name] = Layer.new(type, kind, span.duration)
+                @txns_agg[txn.name].spans[span.name].id = span.id
+                @txns_agg[txn.name].spans[span.name].pid = span.transaction_id
               else
-                @txn_aggs[txn_name].spans[span_name].aggregate! span.duration
+                @txns_agg[txn.name].spans[span.name].aggregate! span.duration
               end
+              spans_present = true              
             end
-            spans_present = true
           end
 
           if spans_present
@@ -211,11 +183,11 @@ module Atatus
               trace_txn = txn
               trace_txn.spans = @spans[txn.id]
 
-              if @trace_aggs.length < 5
-                @trace_aggs.push(trace_txn)
+              if @traces_agg.length < 5
+                @traces_agg.push(trace_txn)
               else
                 i = rand(5)
-                @trace_aggs[i] = trace_txn
+                @traces_agg[i] = trace_txn
               end
             end
           end
@@ -224,25 +196,30 @@ module Atatus
             @spans.delete(txn.id)
           end
 
-          status_code = txn.context.response.status_code
+          if 
+            !txn.context.nil? && 
+            !txn.context.response.nil? && 
+            !txn.context.response.status_code.nil?
+          then
+            status_code = txn.context.response.status_code
 
-          if status_code >= 400 && status_code != 404
-            if !@error_metrics.has_key?(txn_name)
-              @error_metrics[txn_name] = {status_code => 1}
-            else
-              if !@error_metrics[txn_name].has_key?(status_code)
-                @error_metrics[txn_name][status_code] = 1
+            if status_code >= 400 && status_code != 404
+              if !@error_metrics_agg.key?(txn.name)
+                @error_metrics_agg[txn.name] = {status_code => 1}
               else
-                @error_metrics[txn_name][status_code] += 1
+                if !@error_metrics_agg[txn.name].key?(status_code)
+                  @error_metrics_agg[txn.name][status_code] = 1
+                else
+                  @error_metrics_agg[txn.name][status_code] += 1
+                end
               end
-            end
 
-            # puts txn.context.to_yaml
-            if @error_requests.length < 20
-              @error_requests.push({'name' => txn_name, 'context' => txn.context})
-            else
-              i = rand(20)
-              @error_requests[i] = {'name' => txn_name, 'context' => txn.context}
+              if @error_requests_agg.length < 20
+                @error_requests_agg.push({'name' => txn.name, 'context' => txn.context})
+              else
+                i = rand(20)
+                @error_requests_agg[i] = {'name' => txn.name, 'context' => txn.context}
+              end
             end
           end
 
@@ -257,7 +234,7 @@ module Atatus
           debug '%s: Starting collector worker', pid_str
 
           while @running
-            start_time = Time.now
+            start_time = (Time.now.to_f * 1000).to_i
             sleep(60)
             collect start_time
           end
@@ -269,8 +246,6 @@ module Atatus
       end
 
       def collect(start_time)
-        # puts @config.to_yaml
-        # return
         if @config.license_key.nil? || @config.app_name.nil?
           if @config.license_key.nil? && @config.app_name.nil?
             error '%s: Atatus configuration license_key and app_name are missing', pid_str
@@ -290,44 +265,48 @@ module Atatus
         end
         @collect_counter += 1
 
-        end_time = Time.now
+        end_time = (Time.now.to_f * 1000).to_i
         debug '%s: Collecting transactions', pid_str
 
-        txn_data = nil
-        trace_data = nil
-        error_data = nil
+        txns_data = nil
+        traces_data = nil
         error_metrics_data = nil
         error_requests_data = nil
+        errors_data = nil
         metrics_data = nil
 
-        @txn_lock.synchronize do
-          txn_data = @txn_aggs
-          @txn_aggs = Hash.new {}
+        @txns_lock.synchronize do
+          txns_data = @txns_agg
+          @txns_agg = {}
 
-          trace_data = @trace_aggs
-          @trace_aggs = Array.new()
+          traces_data = @traces_agg
+          @traces_agg = []
 
-          error_metrics_data = @error_metrics
-          @error_metrics = Hash.new {}
+          error_metrics_data = @error_metrics_agg
+          @error_metrics_agg = {}
 
-          error_requests_data = @error_requests
-          @error_requests = Array.new()
+          error_requests_data = @error_requests_agg
+          @error_requests_agg = []
         end
 
-        @error_lock.synchronize do
-          error_data = @error_aggs
-          @error_aggs = Array.new()
+        @errors_lock.synchronize do
+          errors_data = @errors_aggs
+          @errors_aggs = []
         end
         
         @metrics_lock.synchronize do
-          metrics_data = @metrics
-          @metrics = Array.new()
+          metrics_data = @metrics_agg
+          @metrics_agg = []
         end
 
-        @transport.txn(start_time, end_time, txn_data) unless txn_data.empty?
-        @transport.trace(start_time, end_time, trace_data) unless trace_data.empty?
+        @transport.txns(start_time, end_time, txns_data) unless txns_data.empty?
+
+        @transport.traces(start_time, end_time, traces_data) unless traces_data.empty?
+
         @transport.error_metrics(start_time, end_time, error_metrics_data, error_requests_data) unless error_metrics_data.empty?
-        @transport.errors(start_time, end_time, error_data) unless error_data.empty?
+
+        @transport.errors(start_time, end_time, errors_data) unless errors_data.empty?
+
         @transport.metrics(start_time, end_time, metrics_data) unless metrics_data.empty?
       end
     end

data/lib/atatus/collector/builder.rb

@@ -1,6 +1,6 @@
 require 'socket'
 require 'atatus/metadata'
-
+require 'yaml'
 module Atatus
   class Builder
     AGENT_NAME = 'Ruby'
@@ -8,6 +8,15 @@ module Atatus
     def initialize(config)
       @config = config
       @metadata = Metadata::SystemInfo.new(config)
+      @container_id = nil
+      if
+        !@metadata.container.nil? &&
+        @metadata.container.key?(:id)
+      then
+        @container_id = @metadata.container[:id]
+      end
+
+      @real_hostname = Socket.gethostname
     end
 
     attr_reader :config
@@ -20,49 +29,47 @@ module Atatus
           name: AGENT_NAME,
           version: VERSION
         },
-        # tags: @config.default_tags,
-        uniqueHostname: Socket.gethostname,
         hostname: @metadata.hostname,
         hostId: @metadata.hwinfo.hostid
       }
-      unless @metadata.container.nil?
-        common[:containerId] = @metadata.container[:id] if @metadata.container.key?(:id)
+      if !@container_id.nil?
+        common[:containerId] = @container_id
       end
       common
     end
 
+    def hostinfo(start_time)
+      payload = common()
+      payload[:timestamp] = start_time
+      payload[:environment] = build_hostinfo_obj()
+      payload
+    end
+
     def txns(start_time, end_time, data)
       payload = common()
-      payload[:startTime] = (start_time.to_f * 1000).to_i
-      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:startTime] = start_time
+      payload[:endTime] = end_time
       payload[:transactions] = build_txns_obj(data)
       payload
     end
 
     def traces(start_time, end_time, data)
       payload = common()
-      payload[:startTime] = (start_time.to_f * 1000).to_i
-      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:startTime] = start_time
+      payload[:endTime] = end_time
       payload[:traces] = build_traces_obj(data)
       payload
     end
 
     def error_metrics(start_time, end_time, metrics_data, requests_data)
       payload = common()
-      payload[:startTime] = (start_time.to_f * 1000).to_i
-      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:startTime] = start_time
+      payload[:endTime] = end_time
       payload[:errorMetrics] = build_error_metrics_obj(metrics_data)
       payload[:errorRequests] = build_error_requests_obj(requests_data)
       payload
     end
 
-    def hostinfo(start_time)
-      payload = common()
-      payload[:timestamp] = (start_time.to_f * 1000).to_i
-      payload[:environment] = build_hostinfo_obj()
-      payload
-    end
-
     def errors(start_time, end_time, error_data)
       payload = common()
       payload[:errors] = build_errors_obj(error_data)
@@ -71,8 +78,8 @@ module Atatus
 
     def metrics(start_time, end_time, metric_data)
       payload = common()
-      payload[:startTime] = (start_time.to_f * 1000).to_i
-      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:startTime] = start_time
+      payload[:endTime] = end_time
       payload[:ruby] = metric_data
       payload
     end
@@ -83,99 +90,45 @@ module Atatus
       Util.truncate(value)
     end
 
-    def build_request(context)
-      return unless context
-      return unless context.request
-
-      request = {
-        accept: context.request.headers['Accept'],
-        'accept-encoding': context.request.headers['Accept-Encoding'],
-        'accept-language': context.request.headers['Accept-Language'],
-        host: context.request.url.hostname,
-        port: (context.request.url.port).to_i,
-        method: context.request.method,
-        userAgent: context.request.headers['User-Agent'],
-        path: context.request.url.pathname
-      }
-      unless context.response.nil?
-        unless context.response.status_code.nil?
-          request[:statusCode] = context.response.status_code
-        end
-      end
-      request
+    def build_hostinfo_obj()
+      environment = {}
+      environment[:gems] = build_hostinfo_gems()
+      environment[:host] = build_hostinfo_env_host()
+      environment[:settings] = build_hostinfo_env_settings()
+      environment
     end
 
-    def build_error_requests_obj(requests_data)
-      error_requests = []
-      requests_data.each do |v|
-        error_request = {}
-        error_request[:name] = v['name']
-        error_request[:type] = @config.framework_name
-        error_request[:kind] = "Ruby"
-        error_request[:request] = build_request(v['context'])
-        error_requests << error_request
+    def build_hostinfo_env_host()
+      host_info = {
+        cpu: [@metadata.hwinfo.cpuinfo],
+        ram: @metadata.hwinfo.meminfo,
+        hostname: @real_hostname,
+        bootId: @metadata.hwinfo.hostid,
+        hostId: @metadata.hwinfo.hostid,
+        os: @metadata.osinfo.os,
+        kernel: @metadata.osinfo.kernel
+      }
+      if !@container_id.nil?
+        host_info[:containerId] = @container_id
       end
-      error_requests
+      host_info
     end
 
-    def build_errors_obj(data)
-      errors = []
-      data.each do |v|
-        error = {}
-        error[:timestamp] = v.timestamp
-        unless v.transaction.nil?
-          error[:transaction] = v.transaction[:name] if v.transaction.key?(:name)
-        end
-        error[:request] = build_request(v.context)
-        error[:exceptions] = []
-        exception = {}
-        exception[:class] = v.exception.type
-        exception[:message] = v.exception.message
-        exception[:stacktrace] = []
-        unless v.exception.stacktrace.nil?
-          unless v.exception.stacktrace.frames.nil?
-            v.exception.stacktrace.frames.each do |f|
-              frame = {}
-              frame[:f] = f.filename
-              frame[:m] = f.function
-              frame[:ln] = f.lineno
-              if f.library_frame == false
-                frame[:inp] = true
-                unless f.context_line.nil?
-                  frame[:code] = []
-
-                  unless f.pre_context.nil?
-                    psize = f.pre_context.size
-                    lineno = 0
-                    if f.lineno - psize >= 0
-                      lineno = f.lineno - psize
-                    end
-                    f.pre_context.each do |c|
-                      frame[:code].push([lineno.to_s, c])
-                      lineno += 1
-                    end
-                  end
-
-                  frame[:code].push([f.lineno.to_s, f.context_line])
+    def build_hostinfo_env_settings()
+      {
+        agentVersion: VERSION,
+        appName: @config.app_name,
+        framework: @config.framework_name,
+        frameworkVersion: @config.framework_version,
+        logLevel: @config.log_level,
+        ruby: RUBY_VERSION
+      }
+    end
 
-                  unless f.post_context.nil?
-                    psize = f.post_context.size
-                    lineno = f.lineno + 1
-                    f.post_context.each do |c|
-                      frame[:code].push([lineno.to_s, c])
-                      lineno += 1
-                    end
-                  end
-                end
-              end
-              exception[:stacktrace] << frame
-            end
-          end
-        end
-        error[:exceptions] << exception
-        errors << error
-      end
-      errors
+    def build_hostinfo_gems()
+      Bundler.rubygems.all_specs.map {|spec| [spec.name, spec.version.to_s]}.sort.to_h
+    rescue => e
+      {}
     end
 
     def build_metric(name, value)
@@ -190,6 +143,38 @@ module Atatus
       }
     end
 
+    def build_request(context)
+      request = {}
+      return request unless context
+
+      if !context.request.nil?
+        r = context.request
+        request[:method] = r.method if !r.method.nil?
+        if !r.headers.nil?
+          h = r.headers
+          request[:accept] = h['Accept'] if h.key?('Accept')
+          request[:'accept-encoding'] = h['Accept-Encoding'] if h.key?('Accept-Encoding')
+          request[:'accept-language'] = h['Accept-Language'] if h.key?('Accept-Language')
+          request[:'userAgent'] = h['User-Agent'] if h.key?('User-Agent')
+        end
+
+        if !r.url.nil?
+          u = r.url
+          request[:host] = u.hostname if !u.hostname.nil?
+          request[:port] = (u.port).to_i if !u.port.nil?
+          request[:path] = u.pathname if !u.pathname.nil?
+        end
+      end
+
+      if !context.response.nil?
+        if !context.response.status_code.nil?
+          request[:statusCode] = context.response.status_code
+        end
+      end
+
+      request
+    end
+
     def build_txns_obj(data)
       txns = []
       data.each do |t, v|
@@ -207,49 +192,60 @@ module Atatus
     def build_traces_obj(data)
       traces = []
       data.each do |txn|
+        if
+          txn.name.nil? ||
+          txn.timestamp.nil? ||
+          txn.duration.nil?
+        then
+          next
+        end
+
         trace = {}
         trace[:name] = txn.name
-        trace[:type] = @config.framework_name
-        trace[:kind] = "Ruby"
+        trace[:type] = @config.framework_name || AGENT_NAME
+        trace[:kind] = AGENT_NAME
         trace[:start] = txn.timestamp
         trace[:duration] = Util.ms(txn.duration)
-        trace[:request] = build_request(txn.context)
+        if !txn.context.nil?
+          trace[:request] = build_request(txn.context)
+        end
         trace[:entries] = []
         trace[:funcs] = []
         i = 0
 
-        unless txn.spans.nil?
-          unless txn.spans.empty?
-            txn.spans.each do |span|
-              entry = {}
-              entry[:lv] = 1
-              if span.timestamp >= txn.timestamp
-                entry[:so] = Util.ms(span.timestamp - txn.timestamp)
-              else
-                entry[:so] = 0
-              end
-              entry[:du] = Util.ms(span.duration)
-              entry[:ly] = {}
-              entry[:ly][:name] = span.name
-              entry[:ly][:type] = Atatus::Collector::Layer.span_type(span.subtype)
-              entry[:ly][:kind] = Atatus::Collector::Layer.span_kind(span.type)
-              unless span.context.nil?
-                unless span.context.db.nil?
-                  unless span.context.db.statement.nil?
-                    entry[:dt] = {}
-                    entry[:dt][:query] = span.context.db.statement
-                  end
-                end
-              end
-              trace[:entries] << entry
-              func_index = trace[:funcs].index(span.name)
-              if func_index.nil?
-                trace[:funcs] << span.name
-                func_index = i
-                i = i + 1
-              end
-              entry[:i] = func_index
+        if
+          !txn.spans.nil? &&
+          !txn.spans.empty?
+        then
+          txn.spans.each do |span|
+            entry = {}
+            entry[:lv] = 1
+            if span.timestamp >= txn.timestamp
+              entry[:so] = Util.ms(span.timestamp - txn.timestamp)
+            else
+              entry[:so] = 0
             end
+            entry[:du] = Util.ms(span.duration)
+            entry[:ly] = {}
+            entry[:ly][:name] = span.name
+            entry[:ly][:type] = Atatus::Collector::Layer.span_type(span.subtype)
+            entry[:ly][:kind] = Atatus::Collector::Layer.span_kind(span.type)
+            if
+              !span.context.nil? &&
+              !span.context.db.nil? &&
+              !span.context.db.statement.nil?
+            then
+              entry[:dt] = {}
+              entry[:dt][:query] = span.context.db.statement
+            end
+            trace[:entries] << entry
+            func_index = trace[:funcs].index(span.name)
+            if func_index.nil?
+              trace[:funcs] << span.name
+              func_index = i
+              i = i + 1
+            end
+            entry[:i] = func_index
           end
         end
 
@@ -263,55 +259,123 @@ module Atatus
       metrics_data.each do |t, v|
         error_metric = {}
         error_metric[:name] = t
-        error_metric[:type] = @config.framework_name
-        error_metric[:kind] = "Ruby"
+        error_metric[:type] = @config.framework_name || AGENT_NAME
+        error_metric[:kind] = AGENT_NAME
         error_metric[:statusCodes] = v
         error_metrics << error_metric
       end
       error_metrics
     end
 
-    def build_hostinfo_obj()
-      environment = {}
-      environment[:gems] = get_gem_list
-      environment[:host] = build_hostinfo_env_host()
-      environment[:settings] = build_hostinfo_env_settings()
-      environment
-    end
-
-    def build_hostinfo_env_host()
-      host_info = {
-        cpu: [@metadata.hwinfo.cpuinfo],
-        ram: @metadata.hwinfo.meminfo,
-        hostname: @metadata.hostname,
-        uniqueHostname: Socket.gethostname,
-        bootId: @metadata.hwinfo.hostid,
-        hostId: @metadata.hwinfo.hostid,
-        os: @metadata.osinfo.os,
-        kernel: @metadata.osinfo.kernel
-      }
-      unless @metadata.container.nil?
-        host_info[:containerId] = @metadata.container[:id] if @metadata.container.key?(:id)
+    def build_error_requests_obj(requests_data)
+      error_requests = []
+      requests_data.each do |v|
+        if
+          !v.key?('name') ||
+          !v.key?('context')
+        then
+          next
+        end
+        error_request = {}
+        error_request[:name] = v['name']
+        error_request[:type] = @config.framework_name || AGENT_NAME
+        error_request[:kind] = AGENT_NAME
+        error_request[:request] = build_request(v['context'])
+        error_requests << error_request
       end
-      host_info
+      error_requests
     end
 
-    def build_hostinfo_env_settings()
-      {
-        agentVersion: VERSION,
-        appName: @config.app_name,
-        framework: @config.framework_name,
-        frameworkVersion: @config.framework_version,
-        logLevel: @config.log_level,
-        ruby: RUBY_VERSION
-      }
-    end
+    def build_errors_obj(data)
+      errors = []
+      data.each do |v|
+        if
+          v.timestamp.nil? ||
+          v.exception.nil?
+        then
+          next
+        end
 
-    def get_gem_list()
-      Bundler.rubygems.all_specs.map {|spec| [spec.name, spec.version.to_s]}.sort.to_h
-    rescue => e
-      # logger.warn("Couldn't fetch Gem information: #{e.message}")
-      {}
+        if
+          v.exception.type.nil? ||
+          v.exception.message.nil?
+        then
+          next
+        end
+
+        error = {}
+        error[:timestamp] = v.timestamp
+
+        if
+          !v.transaction.nil? &&
+          v.transaction.key?(:name)
+        then
+          error[:transaction] = v.transaction[:name]
+        end
+
+        if !v.context.nil?
+          error[:request] = build_request(v.context)
+        end
+        error[:exceptions] = []
+        exception = {}
+        exception[:class] = v.exception.type
+        exception[:message] = v.exception.message
+        exception[:stacktrace] = []
+        if
+          !v.exception.stacktrace.nil? &&
+          !v.exception.stacktrace.frames.nil?
+        then
+          v.exception.stacktrace.frames.each do |f|
+            if
+              f.filename.nil? ||
+              f.function.nil? ||
+              f.lineno.nil? ||
+              f.library_frame.nil?
+            then
+              next
+            end
+
+            frame = {}
+            frame[:f] = f.filename
+            frame[:m] = f.function
+            frame[:ln] = f.lineno
+            if f.library_frame == false
+              frame[:inp] = true
+              if !f.context_line.nil?
+                frame[:code] = []
+
+                if !f.pre_context.nil?
+                  psize = f.pre_context.size
+                  lineno = 0
+                  if f.lineno - psize >= 0
+                    lineno = f.lineno - psize
+                  end
+                  f.pre_context.each do |c|
+                    frame[:code].push([lineno.to_s, c])
+                    lineno += 1
+                  end
+                end
+
+                frame[:code].push([f.lineno.to_s, f.context_line])
+
+                if !f.post_context.nil?
+                  psize = f.post_context.size
+                  lineno = f.lineno + 1
+                  f.post_context.each do |c|
+                    frame[:code].push([lineno.to_s, c])
+                    lineno += 1
+                  end
+                end
+              end
+            end
+            exception[:stacktrace] << frame
+          end
+        end
+        error[:exceptions] << exception
+        errors << error
+      end
+      errors
     end
+
   end
 end

data/lib/atatus/collector/layer.rb

@@ -0,0 +1,58 @@
+
+module Atatus
+  module Collector
+    class Layer
+      def initialize(type, kind, duration)
+        @type = type
+        @kind = kind
+        @count = 1
+        @min = duration
+        @max = duration
+        @total = duration
+      end
+
+      attr_reader :type, :kind, :count, :min, :max, :total
+      attr_accessor :id, :pid
+
+      def aggregate!(duration)
+        @count += 1
+        @min = duration if duration < @min
+        @max = duration if duration > @max
+        @total += duration
+      end
+
+      def self.span_kind(value)
+        return KINDS.fetch(value, value)
+      end
+
+      def self.span_type(value)
+        return TYPES.fetch(value, value)
+      end
+
+      private
+      KINDS = {
+        'db' => 'Database',
+        'cache' => 'Database',
+        'ext' => 'Remote',
+        'websocket' => 'Remote',
+        'template' => 'Template'
+      }.freeze
+
+      TYPES = {
+        'mysql' => 'MySQL',
+        'mysql2' => 'MySQL',
+        'postgresql' => 'Postgres',
+        'mssql' => 'MS SQL',
+        'mongodb' => 'MongoDB',
+        'redis' => 'Redis',
+        'graphql' => 'GraphQL',
+        'elasticsearch' => 'Elasticsearch',
+        'cassandra' => 'Cassandra',
+        'http' => 'External Requests',
+        'http2' => 'External Requests',
+        'http_rb' => 'External Requests',
+        'net_http' => 'External Requests'
+      }.freeze
+    end
+  end
+end

data/lib/atatus/collector/transport.rb

@@ -2,11 +2,10 @@ require 'json'
 require 'thread'
 require 'net/http'
 require 'atatus/collector/builder'
-require 'json'
 
 module Atatus
   class BaseTransport
-    # include Logging
+    include Logging
 
     TXN_ENDPOINT = '/track/apm/txn'.freeze
     TRACE_ENDPOINT = '/track/apm/trace'.freeze
@@ -15,23 +14,32 @@ module Atatus
     ERROR_METRIC_ENDPOINT = "/track/apm/error_metric".freeze
     METRIC_ENDPOINT = "/track/apm/metric".freeze
 
-    def initialize(config, hostname, port)
+    def initialize(config)
       @config = config
-      @hostname = hostname
-      @port = port
 
-      @builder = Atatus::Builder.new(config)
+      @notify_host = @config.notify_host
+      @uri = URI(@notify_host)
+      if not @uri.kind_of?(URI::HTTPS) and not @uri.kind_of?(URI::HTTP)
+        @notify_host = "https://apm-rx.atatus.com"
+        @uri = URI(@notify_host)
+      end
 
+      @builder = Atatus::Builder.new(config)
       @headers = {}
       @headers['Content-Type'] = "application/json"
     end
 
-    def txn(start_time, end_time, data)
+    def hostinfo(start_time)
+      payload = @builder.hostinfo(start_time)
+      post(HOSTINFO_ENDPOINT, payload)
+    end
+
+    def txns(start_time, end_time, data)
       payload = @builder.txns(start_time, end_time, data)
       post(TXN_ENDPOINT, payload)
     end
 
-    def trace(start_time, end_time, data)
+    def traces(start_time, end_time, data)
       payload = @builder.traces(start_time, end_time, data)
       post(TRACE_ENDPOINT, payload)
     end
@@ -41,11 +49,6 @@ module Atatus
       post(ERROR_METRIC_ENDPOINT, payload)
     end
 
-    def hostinfo(start_time)
-      payload = @builder.hostinfo(start_time)
-      post(HOSTINFO_ENDPOINT, payload)
-    end
-
     def errors(start_time, end_time, error_data)
       payload = @builder.errors(start_time, end_time, error_data)
       post(ERROR_ENDPOINT, payload)
@@ -59,14 +62,51 @@ module Atatus
     private
 
     def post(endpoint, data)
-      request = Net::HTTP::Post.new(endpoint, @headers)
-      request.body = ::JSON.dump(data)
-      http = Net::HTTP.new(@hostname, @port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      response = http.start { |http| http.request(request) }
-    rescue StandardError => e
-      puts "Sending to Atatus backend failed: ", e.inspect, response # To fix
+      # puts ::JSON.pretty_generate(data, :max_nesting => false)
+      if @blocked == true and endpoint != HOSTINFO_ENDPOINT
+        return
+      end
+
+      begin
+        request = Net::HTTP::Post.new(endpoint, @headers)
+        request.body = ::JSON.dump(data)
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        response = http.start { |http| http.request(request) }
+      rescue SystemCallError, Timeout::Error, EOFError, SocketError => e
+        puts "Atatus transport [#{@notify_host}#{endpoint}] failed with exception: #{e}"
+      end
+
+      if @blocked == true
+        @blocked = false
+      end
+
+      case response
+      when Net::HTTPSuccess
+        true
+      when Net::HTTPBadRequest
+        if not response.body
+          error format('Atatus transport status 400, failed without content')
+          return
+        end
+
+        resp = JSON.parse response.body
+        if resp
+          if resp.key?(:blocked)
+            @blocked = resp[:blocked]
+            if @blocked == true
+              if resp.key?(:errorMessage)
+                error format('Atatus blocked from sending data as: %s', resp[:errorMessage])
+                return
+              end
+            end
+          end
+        end
+
+        error format('Atatus transport status 400, failed with content: %s', response.message)
+      else
+      end
     end
   end
 end

data/lib/atatus/config.rb

@@ -22,9 +22,10 @@ module Atatus
     # rubocop:disable Metrics/LineLength, Layout/ExtraSpacing
     option :app_name,                          type: :string
     option :license_key,                       type: :string
+    option :notify_host,                       type: :string, default: 'https://apm-rx.atatus.com'
     option :trace_threshold,                   type: :int,    default: 2000
     option :config_file,                       type: :string, default: 'config/atatus.yml'
-    option :server_url,                        type: :string, default: 'http://localhost:8200'
+    option :server_url,                        type: :string, default: ''
     option :secret_token,                      type: :string
 
     option :active,                            type: :bool,   default: true

data/lib/atatus/metadata/system_info/hw_info.rb

@@ -92,7 +92,7 @@ module Atatus
         def read_from_meminfo!
           return unless File.exist?(LINUX_MEMINFO_PATH)
           meminfo = File.read(LINUX_MEMINFO_PATH)
-          self.meminfo_total = meminfo.scan(TOTAL_MEMORY_REGEX).flatten.first.to_i
+          self.meminfo_total = (meminfo.scan(TOTAL_MEMORY_REGEX).flatten.first.to_i) * 1024 # to bytes
         end
         # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize

data/lib/atatus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Atatus
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atatus
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Atatus
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-13 00:00:00.000000000 Z
+date: 2019-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -74,6 +74,7 @@ files:
 - lib/atatus/central_config/cache_control.rb
 - lib/atatus/collector/base.rb
 - lib/atatus/collector/builder.rb
+- lib/atatus/collector/layer.rb
 - lib/atatus/collector/transport.rb
 - lib/atatus/config.rb
 - lib/atatus/config/bytes.rb