hoss-agent 1.0.9

data/lib/hoss/transport/serializers.rb

@@ -0,0 +1,113 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Hoss
+  module Transport
+    # @api private
+    module Serializers
+      # @api private
+      class UnrecognizedResource < InternalError; end
+
+      # @api private
+      class Serializer
+        def initialize(config)
+          @config = config
+        end
+
+        attr_reader :config
+
+        private
+
+        def ms(micros)
+          micros.to_f / 1_000
+        end
+
+        def keyword_field(value)
+          Util.truncate(value)
+        end
+
+        def keyword_object(hash)
+          return unless hash
+
+          hash.tap do |h|
+            h.each { |k, v| hash[k] = keyword_field(v) }
+          end
+        end
+
+        def mixed_object(hash)
+          return unless hash
+
+          hash.tap do |h|
+            h.each do |k, v|
+              hash[k] = v.is_a?(String) ? keyword_field(v) : v
+            end
+          end
+        end
+      end
+
+      # @api private
+      class Container
+        def initialize(config)
+          # @transaction = Serializers::TransactionSerializer.new(config)
+          # @span = Serializers::SpanSerializer.new(config)
+          @report = Serializers::ReportSerializer.new(config)
+          @event = Serializers::EventSerializer.new(config)
+          @error = Serializers::ErrorSerializer.new(config)
+          @metadata = Serializers::MetadataSerializer.new(config)
+          # @metricset = Serializers::MetricsetSerializer.new(config)
+        end
+
+        attr_reader :report, :event, :error, :metadata, :metricset
+        def serialize(resource)
+          case resource
+          # when Transaction
+          #   transaction.build(resource)
+          # when Span
+          #   span.build(resource)
+          when Report
+            report.build(resource)
+          when Event
+            event.build(resource)
+          when Error
+            error.build(resource)
+          # when Metricset
+          #   metricset.build(resource)
+          when Metadata
+            metadata.build(resource)
+          else
+            raise UnrecognizedResource, resource.inspect
+          end
+        end
+      end
+
+      def self.new(config)
+        Container.new(config)
+      end
+    end
+  end
+end
+
+require 'hoss/transport/serializers/context_serializer'
+# require 'hoss/transport/serializers/transaction_serializer'
+# require 'hoss/transport/serializers/span_serializer'
+require 'hoss/transport/serializers/report_serializer'
+require 'hoss/transport/serializers/event_serializer'
+require 'hoss/transport/serializers/error_serializer'
+# require 'hoss/transport/serializers/metricset_serializer'
+require 'hoss/transport/serializers/metadata_serializer'

data/lib/hoss/transport/serializers/context_serializer.rb

@@ -0,0 +1,112 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Hoss
+  module Transport
+    module Serializers
+      # @api private
+      class ContextSerializer < Serializer
+        def build(context)
+          return nil if context.nil? || context.empty?
+
+          {
+            custom: context.custom,
+            tags: mixed_object(context.labels),
+            request: build_request(context.request),
+            response: build_response(context.response),
+            user: build_user(context.user),
+            service: build_service(context.service)
+          }
+        end
+
+        private
+
+        def build_request(request)
+          return unless request
+
+          {
+            body: request.body,
+            cookies: request.cookies,
+            env: request.env,
+            headers: request.headers,
+            http_version: keyword_field(request.http_version),
+            method: keyword_field(request.method),
+            socket: build_socket(request.socket),
+            url: build_url(request.url)
+          }
+        end
+
+        def build_response(response)
+          return unless response
+
+          {
+            status_code: response.status_code.to_i,
+            headers: response.headers,
+            headers_sent: response.headers_sent,
+            finished: response.finished
+          }
+        end
+
+        def build_user(user)
+          return if !user || user.empty?
+
+          {
+            id: keyword_field(user.id),
+            email: keyword_field(user.email),
+            username: keyword_field(user.username)
+          }
+        end
+
+        def build_socket(socket)
+          return unless socket
+
+          {
+            remote_addr: socket.remote_addr,
+            encrypted: socket.encrypted
+          }
+        end
+
+        def build_url(url)
+          return unless url
+
+          {
+            protocol: keyword_field(url.protocol),
+            full: keyword_field(url.full),
+            hostname: keyword_field(url.hostname),
+            port: keyword_field(url.port),
+            pathname: keyword_field(url.pathname),
+            search: keyword_field(url.search),
+            hash: keyword_field(url.hash)
+          }
+        end
+
+        def build_service(service)
+          return unless service
+
+          {
+            framework: {
+              name: keyword_field(service.framework.name),
+              version: keyword_field(service.framework.version)
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hoss/transport/serializers/error_serializer.rb

@@ -0,0 +1,92 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Hoss
+  module Transport
+    module Serializers
+      # @api private
+      class ErrorSerializer < Serializer
+        def context_serializer
+          @context_serializer ||= ContextSerializer.new(config)
+        end
+
+        def build(error)
+          base = {
+            id: error.id,
+            transaction_id: error.transaction_id,
+            transaction: build_transaction(error.transaction),
+            trace_id: error.trace_id,
+            parent_id: error.parent_id,
+
+            culprit: keyword_field(error.culprit),
+            timestamp: error.timestamp
+          }
+
+          if (context = context_serializer.build(error.context))
+            base[:context] = context
+          end
+
+          if (exception = error.exception)
+            base[:exception] = build_exception exception
+          end
+
+          if (log = error.log)
+            base[:log] = build_log log
+          end
+
+          { error: base }
+        end
+
+        private
+
+        def build_exception(exception)
+          {
+            message: exception.message,
+            type: keyword_field(exception.type),
+            module: keyword_field(exception.module),
+            code: keyword_field(exception.code),
+            attributes: exception.attributes,
+            stacktrace: exception.stacktrace.to_a,
+            handled: exception.handled,
+            cause: exception.cause && [build_exception(exception.cause)]
+          }
+        end
+
+        def build_log(log)
+          {
+            message: log.message,
+            level: keyword_field(log.level),
+            logger_name: keyword_field(log.logger_name),
+            param_message: keyword_field(log.param_message),
+            stacktrace: log.stacktrace.to_a
+          }
+        end
+
+        def build_transaction(transaction)
+          return unless transaction
+
+          {
+            sampled: transaction[:sampled],
+            type: keyword_field(transaction[:type])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hoss/transport/serializers/event_serializer.rb

@@ -0,0 +1,73 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Hoss
+  module Transport
+    module Serializers
+      # @api private
+      class EventSerializer < Serializer
+        def build(event)
+          r = {
+              eventId: event.id,
+              request: build_request(event.request),
+              response: build_response(event.response),
+          }
+          r['error'] = build_error(event.error) if event.error
+          r
+        end
+
+        private
+
+        def build_request(request)
+          return unless request
+          body = request.body ? Base64.encode64(request.body).strip : nil
+
+          {
+            method: request.method,
+            url: request.url,
+            headers: request.headers,
+            body: body || '',
+            receivedAt: request.received_at
+          }
+        end
+
+        def build_response(response)
+          return unless response
+          body = response.body ? Base64.encode64(response.body).strip : nil
+
+          {
+            statusCode: response.status_code,
+            headers: response.headers,
+            body: body || '',
+            receivedAt: response.received_at
+          }
+        end
+
+        def build_error(error)
+          return unless error
+
+          {
+            type: error.type,
+            receivedAt: error.received_at
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hoss/transport/serializers/metadata_serializer.rb

@@ -0,0 +1,92 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Hoss
+  module Transport
+    module Serializers
+      # @api private
+      class MetadataSerializer < Serializer
+        def build(metadata)
+          {
+            metadata: {
+              service: build_service(metadata.service),
+              process: build_process(metadata.process),
+              system: build_system(metadata.system),
+              labels: build_labels(metadata.labels)
+            }
+          }
+        end
+
+        private
+
+        def build_service(service)
+          base =
+            {
+              name: keyword_field(service.name),
+              environment: keyword_field(service.environment),
+              version: keyword_field(service.version),
+              agent: {
+                name: keyword_field(service.agent.name),
+                version: keyword_field(service.agent.version)
+              },
+              framework: {
+                name: keyword_field(service.framework.name),
+                version: keyword_field(service.framework.version)
+              },
+              language: {
+                name: keyword_field(service.language.name),
+                version: keyword_field(service.language.version)
+              },
+              runtime: {
+                name: keyword_field(service.runtime.name),
+                version: keyword_field(service.runtime.version)
+              }
+            }
+
+          if node_name = service.node_name
+            base[:node] = { name: keyword_field(node_name) }
+          end
+
+          base
+        end
+
+        def build_process(process)
+          {
+            pid: process.pid,
+            title: keyword_field(process.title),
+            argv: process.argv
+          }
+        end
+
+        def build_system(system)
+          {
+            hostname: keyword_field(system.hostname),
+            architecture: keyword_field(system.architecture),
+            platform: keyword_field(system.platform),
+            kubernetes: keyword_object(system.kubernetes)
+          }
+        end
+
+        def build_labels(labels)
+          keyword_object(labels)
+        end
+      end
+    end
+  end
+end