solarwinds_apm 6.1.2 → 7.0.0.prev1

data/lib/solarwinds_apm/support/resource_detector/aws/ec2.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'net/http'
+require 'json'
+require 'opentelemetry/common'
+require 'opentelemetry/semantic_conventions/resource'
+
+module OpenTelemetry
+  module Resource
+    module Detector
+      module AWS
+        # EC2 contains detect class method for determining EC2 resource attributes
+        module EC2
+          extend self
+
+          # EC2 metadata service endpoints and constants
+          EC2_METADATA_HOST = '169.254.169.254'
+          TOKEN_ENDPOINT = '/latest/api/token'
+          IDENTITY_DOCUMENT_ENDPOINT = '/latest/dynamic/instance-identity/document'
+          HOSTNAME_ENDPOINT = '/latest/meta-data/hostname'
+
+          TOKEN_HEADER = 'X-aws-ec2-metadata-token'
+          TOKEN_TTL_HEADER = 'X-aws-ec2-metadata-token-ttl-seconds'
+          TOKEN_TTL_VALUE = '60'
+
+          # Timeout in seconds for HTTP requests
+          HTTP_TIMEOUT = 1
+
+          # Create a constant for resource semantic conventions
+          RESOURCE = ::OpenTelemetry::SemanticConventions::Resource
+
+          def detect
+            # Implementation for EC2 detection supporting both IMDSv1 and IMDSv2
+            resource_attributes = {}
+
+            begin
+              # Attempt to get IMDSv2 token - this will fail if IMDSv2 is not supported
+              # but we'll still try IMDSv1 in that case
+              token = fetch_token
+
+              # Get instance identity document which contains most metadata
+              # Will try with token (IMDSv2) or without token (IMDSv1)
+              identity = fetch_identity_document(token) || {}
+              return ::OpenTelemetry::SDK::Resources::Resource.create({}) if identity.empty?
+
+              hostname = fetch_hostname(token)
+
+              # Set resource attributes from the identity document
+              resource_attributes[RESOURCE::CLOUD_PROVIDER] = 'aws'
+              resource_attributes[RESOURCE::CLOUD_PLATFORM] = 'aws_ec2'
+              resource_attributes[RESOURCE::CLOUD_ACCOUNT_ID] = identity['accountId']
+              resource_attributes[RESOURCE::CLOUD_REGION] = identity['region']
+              resource_attributes[RESOURCE::CLOUD_AVAILABILITY_ZONE] = identity['availabilityZone']
+
+              resource_attributes[RESOURCE::HOST_ID] = identity['instanceId']
+              resource_attributes[RESOURCE::HOST_TYPE] = identity['instanceType']
+              resource_attributes[RESOURCE::HOST_NAME] = hostname
+            rescue StandardError => e
+              ::OpenTelemetry.handle_error(exception: e, message: 'EC2 resource detection failed')
+              return ::OpenTelemetry::SDK::Resources::Resource.create({})
+            end
+
+            # Filter out nil or empty values
+            resource_attributes.delete_if { |_key, value| value.nil? || value.empty? }
+            ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+          end
+
+          private
+
+          # Fetches an IMDSv2 token from the EC2 metadata service
+          #
+          # @return [String, nil] The token or nil if the request failed
+          def fetch_token
+            uri = URI.parse("http://#{EC2_METADATA_HOST}#{TOKEN_ENDPOINT}")
+            request = Net::HTTP::Put.new(uri)
+            request[TOKEN_TTL_HEADER] = TOKEN_TTL_VALUE
+
+            response = make_request(uri, request)
+            return nil unless response.is_a?(Net::HTTPSuccess)
+
+            response.body
+          end
+
+          # Fetches the instance identity document which contains EC2 instance metadata
+          #
+          # @param token [String, nil] IMDSv2 token (optional for IMDSv1)
+          # @return [Hash, nil] Parsed identity document or nil if the request failed
+          def fetch_identity_document(token)
+            uri = URI.parse("http://#{EC2_METADATA_HOST}#{IDENTITY_DOCUMENT_ENDPOINT}")
+            request = Net::HTTP::Get.new(uri)
+            request[TOKEN_HEADER] = token if token
+
+            response = make_request(uri, request)
+            return nil unless response.is_a?(Net::HTTPSuccess)
+
+            begin
+              JSON.parse(response.body)
+            rescue JSON::ParserError
+              nil
+            end
+          end
+
+          # Fetches the EC2 instance hostname
+          #
+          # @param token [String, nil] IMDSv2 token (optional for IMDSv1)
+          # @return [String, nil] The hostname or nil if the request failed
+          def fetch_hostname(token)
+            uri = URI.parse("http://#{EC2_METADATA_HOST}#{HOSTNAME_ENDPOINT}")
+            request = Net::HTTP::Get.new(uri)
+            request[TOKEN_HEADER] = token if token
+
+            response = make_request(uri, request)
+            return nil unless response.is_a?(Net::HTTPSuccess)
+
+            response.body
+          end
+
+          # Makes an HTTP request with timeout handling
+          #
+          # @param uri [URI] The request URI
+          # @param request [Net::HTTP::Request] The request to perform
+          # @return [Net::HTTPResponse, nil] The response or nil if the request failed
+          def make_request(uri, request)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.open_timeout = HTTP_TIMEOUT
+            http.read_timeout = HTTP_TIMEOUT
+
+            begin
+              ::OpenTelemetry::Common::Utilities.untraced do
+                http.request(request)
+              end
+            rescue StandardError
+              ::OpenTelemetry.logger.debug { 'EC2 metadata service request failed' }
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/support/resource_detector/aws/ecs.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'net/http'
+require 'json'
+require 'socket'
+require 'opentelemetry/common'
+require 'opentelemetry/semantic_conventions/resource'
+
+module OpenTelemetry
+  module Resource
+    module Detector
+      module AWS
+        # ECS contains detect class method for determining the ECS resource attributes
+        module ECS
+          extend self
+
+          # Container ID length from cgroup file
+          CONTAINER_ID_LENGTH = 64
+
+          # HTTP request timeout in seconds
+          HTTP_TIMEOUT = 5
+
+          # Create a constant for resource semantic conventions
+          RESOURCE = ::OpenTelemetry::SemanticConventions::Resource
+
+          def detect
+            # Return empty resource if not running on ECS
+            metadata_uri = ENV.fetch('ECS_CONTAINER_METADATA_URI', nil)
+            metadata_uri_v4 = ENV.fetch('ECS_CONTAINER_METADATA_URI_V4', nil)
+
+            return ::OpenTelemetry::SDK::Resources::Resource.create({}) if metadata_uri.nil? && metadata_uri_v4.nil?
+
+            resource_attributes = {}
+            container_id = fetch_container_id
+
+            # Base ECS resource attributes
+            resource_attributes[RESOURCE::CLOUD_PROVIDER] = 'aws'
+            resource_attributes[RESOURCE::CLOUD_PLATFORM] = 'aws_ecs'
+            resource_attributes[RESOURCE::CONTAINER_NAME] = Socket.gethostname
+            resource_attributes[RESOURCE::CONTAINER_ID] = container_id unless container_id.empty?
+
+            # If v4 endpoint is not available, return basic resource
+            return ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes) if metadata_uri_v4.nil?
+
+            begin
+              # Fetch container and task metadata
+              container_metadata = JSON.parse(http_get(metadata_uri_v4.to_s))
+              task_metadata = JSON.parse(http_get("#{metadata_uri_v4}/task"))
+
+              task_arn = task_metadata['TaskARN']
+              base_arn = task_arn[0..task_arn.rindex(':') - 1]
+
+              cluster = task_metadata['Cluster']
+              cluster_arn = cluster.start_with?('arn:') ? cluster : "#{base_arn}:cluster/#{cluster}"
+
+              # Set ECS-specific attributes
+              resource_attributes[RESOURCE::AWS_ECS_CONTAINER_ARN] = container_metadata['ContainerARN']
+              resource_attributes[RESOURCE::AWS_ECS_CLUSTER_ARN] = cluster_arn
+              resource_attributes[RESOURCE::AWS_ECS_LAUNCHTYPE] = task_metadata['LaunchType'].downcase
+              resource_attributes[RESOURCE::AWS_ECS_TASK_ARN] = task_arn
+              resource_attributes[RESOURCE::AWS_ECS_TASK_FAMILY] = task_metadata['Family']
+              resource_attributes[RESOURCE::AWS_ECS_TASK_REVISION] = task_metadata['Revision']
+
+              # Add logging attributes if awslogs is used
+              logs_attributes = get_logs_resource(container_metadata)
+              resource_attributes.merge!(logs_attributes)
+            rescue StandardError => e
+              ::OpenTelemetry.handle_error(exception: e, message: 'ECS resource detection failed')
+              return ::OpenTelemetry::SDK::Resources::Resource.create({})
+            end
+
+            # Filter out nil or empty values
+            resource_attributes.delete_if { |_key, value| value.nil? || value.empty? }
+            ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+          end
+
+          private
+
+          # Fetches container ID from /proc/self/cgroup file
+          #
+          # @return [String] The container ID or empty string if not found
+          def fetch_container_id
+            begin
+              File.open('/proc/self/cgroup', 'r') do |file|
+                file.each_line do |line|
+                  line = line.strip
+                  # Look for container ID (64 chars) at the end of the line
+                  return line[-CONTAINER_ID_LENGTH..] if line.length > CONTAINER_ID_LENGTH
+                end
+              end
+            rescue Errno::ENOENT => e
+              ::OpenTelemetry.handle_error(exception: e, message: 'Failed to get container ID on ECS')
+            end
+
+            ''
+          end
+
+          # Extracting logging-related resource attributes
+          #
+          # @param container_metadata [Hash] Container metadata from ECS metadata endpoint
+          # @returhn [Hash] Resource attributes for logging configuration
+          def get_logs_resource(container_metadata)
+            log_attributes = {}
+
+            if container_metadata['LogDriver'] == 'awslogs'
+              log_options = container_metadata['LogOptions']
+
+              if log_options
+                logs_region = log_options['awslogs-region']
+                logs_group_name = log_options['awslogs-group']
+                logs_stream_name = log_options['awslogs-stream']
+
+                container_arn = container_metadata['ContainerARN']
+
+                # Parse region from ARN if not specified in log options
+                if logs_region.nil? || logs_region.empty?
+                  region_match = container_arn.match(/arn:aws:ecs:([^:]+):.*/)
+                  logs_region = region_match[1] if region_match
+                end
+
+                # Parse account ID from ARN
+                account_match = container_arn.match(/arn:aws:ecs:[^:]+:([^:]+):.*/)
+                aws_account = account_match[1] if account_match
+
+                logs_group_arn = nil
+                logs_stream_arn = nil
+
+                if logs_region && aws_account
+                  logs_group_arn = "arn:aws:logs:#{logs_region}:#{aws_account}:log-group:#{logs_group_name}" if logs_group_name
+
+                  logs_stream_arn = "arn:aws:logs:#{logs_region}:#{aws_account}:log-group:#{logs_group_name}:log-stream:#{logs_stream_name}" if logs_stream_name && logs_group_name
+                end
+
+                log_attributes[RESOURCE::AWS_LOG_GROUP_NAMES] = [logs_group_name].compact
+                log_attributes[RESOURCE::AWS_LOG_GROUP_ARNS] = [logs_group_arn].compact
+                log_attributes[RESOURCE::AWS_LOG_STREAM_NAMES] = [logs_stream_name].compact
+                log_attributes[RESOURCE::AWS_LOG_STREAM_ARNS] = [logs_stream_arn].compact
+              else
+                ::OpenTelemetry.handle_error(message: 'The metadata endpoint v4 has returned \'awslogs\' as \'LogDriver\', but there is no \'LogOptions\' data')
+              end
+            end
+
+            log_attributes
+          end
+
+          # Makes an HTTP GET request to the specified URL
+          #
+          # @param url [String] The URL to request
+          # @return [String] The response body
+          def http_get(url)
+            uri = URI.parse(url)
+            request = Net::HTTP::Get.new(uri)
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.open_timeout = HTTP_TIMEOUT
+            http.read_timeout = HTTP_TIMEOUT
+
+            ::OpenTelemetry::Common::Utilities.untraced do
+              response = http.request(request)
+              raise "HTTP request failed with status #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+              response.body
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/support/resource_detector/aws/eks.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'net/http'
+require 'json'
+require 'openssl'
+require 'uri'
+require 'opentelemetry/common'
+require 'opentelemetry/semantic_conventions/resource'
+
+module OpenTelemetry
+  module Resource
+    module Detector
+      module AWS
+        # EKS contains detect class method for determining EKS resource attributes
+        module EKS
+          extend self
+
+          # Container ID length from cgroup file
+          CONTAINER_ID_LENGTH = 64
+
+          # HTTP request timeout in seconds
+          HTTP_TIMEOUT = 5
+
+          # Kubernetes token and certificate paths
+          TOKEN_PATH = '/var/run/secrets/kubernetes.io/serviceaccount/token'
+          CERT_PATH = '/var/run/secrets/kubernetes.io/serviceaccount/ca.crt'
+
+          # Kubernetes API paths
+          AWS_AUTH_PATH = '/api/v1/namespaces/kube-system/configmaps/aws-auth'
+          CLUSTER_INFO_PATH = '/api/v1/namespaces/amazon-cloudwatch/configmaps/cluster-info'
+
+          # Create a constant for resource semantic conventions
+          RESOURCE = ::OpenTelemetry::SemanticConventions::Resource
+
+          def detect
+            # Return empty resource if not running on K8s
+            return ::OpenTelemetry::SDK::Resources::Resource.create({}) unless k8s?
+
+            resource_attributes = {}
+
+            begin
+              # Get K8s credentials
+              cred_value = k8s_cred_value
+
+              # Verify this is an EKS cluster
+              unless eks?(cred_value)
+                ::OpenTelemetry.logger.debug('Could not confirm process is running on EKS')
+                return ::OpenTelemetry::SDK::Resources::Resource.create({})
+              end
+
+              # Get cluster name and container ID
+              cluster_name_val = cluster_name(cred_value)
+              container_id_val = container_id
+
+              if container_id_val.empty? && cluster_name_val.empty?
+                ::OpenTelemetry.logger.debug('Neither cluster name nor container ID found on EKS process')
+                return ::OpenTelemetry::SDK::Resources::Resource.create({})
+              end
+
+              # Set resource attributes
+              resource_attributes[RESOURCE::CLOUD_PROVIDER] = 'aws'
+              resource_attributes[RESOURCE::CLOUD_PLATFORM] = 'aws_eks'
+              resource_attributes[RESOURCE::K8S_CLUSTER_NAME] = cluster_name_val unless cluster_name_val.empty?
+              resource_attributes[RESOURCE::CONTAINER_ID] = container_id_val unless container_id_val.empty?
+            rescue StandardError => e
+              ::OpenTelemetry.logger.debug("EKS resource detection failed: #{e.message}")
+              return ::OpenTelemetry::SDK::Resources::Resource.create({})
+            end
+
+            resource_attributes.delete_if { |_key, value| value.nil? || value.empty? }
+            ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+          end
+
+          private
+
+          # Check if running on K8s
+          #
+          # @return [Boolean] true if running on K8s
+          def k8s?
+            File.exist?(TOKEN_PATH) && File.exist?(CERT_PATH)
+          end
+
+          # Get K8s token
+          #
+          # @return [String] K8s token
+          # @raise [StandardError] if token could not be read
+          def k8s_cred_value
+            token = File.read(TOKEN_PATH).strip
+            "Bearer #{token}"
+          rescue StandardError => e
+            ::OpenTelemetry.logger.debug("Failed to get k8s token: #{e.message}")
+            raise e
+          end
+
+          # Check if running on EKS
+          #
+          # @param cred_value [String] K8s credentials
+          # @return [Boolean] true if running on EKS
+          def eks?(cred_value)
+            # Just try to to access the aws-auth configmap
+            # If it exists and we can access it, we're on EKS
+            aws_http_request(AWS_AUTH_PATH, cred_value)
+            true
+          rescue StandardError
+            false
+          end
+
+          # Get EKS cluster name
+          #
+          # @param cred_value [String] K8s credentials
+          # @return [String] Cluster name or empty string if not found
+          def cluster_name(cred_value)
+            begin
+              response = aws_http_request(CLUSTER_INFO_PATH, cred_value)
+              cluster_info = JSON.parse(response)
+              return cluster_info['data']['cluster.name'] if cluster_info['data'] && cluster_info['data']['cluster.name']
+            rescue StandardError => e
+              ::OpenTelemetry.logger.debug("Cannot get cluster name on EKS: #{e.message}")
+            end
+            ''
+          end
+
+          # Get container ID from cgroup file
+          #
+          # @return [String] Container ID or empty string if not found
+          def container_id
+            begin
+              File.open('/proc/self/cgroup', 'r') do |file|
+                file.each_line do |line|
+                  line = line.strip
+                  # Look for container ID (64 chars) at the end of the line
+                  return line[-CONTAINER_ID_LENGTH..] if line.length > CONTAINER_ID_LENGTH
+                end
+              end
+            rescue StandardError => e
+              ::OpenTelemetry.logger.debug("Failed to get container ID on EKS: #{e.message}")
+            end
+            ''
+          end
+
+          # Make HTTP GET request to K8s API
+          #
+          # @param path [String] API path
+          # @param cred_value [String] Authorization header value
+          # @return [String] Response body
+          # @raise [StandardError] if request fails
+          def aws_http_request(path, cred_value)
+            uri = URI.parse("https://kubernetes.default.svc#{path}")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = CERT_PATH
+            http.open_timeout = HTTP_TIMEOUT
+            http.read_timeout = HTTP_TIMEOUT
+
+            request = Net::HTTP::Get.new(uri)
+            request['Authorization'] = cred_value
+
+            ::OpenTelemetry::Common::Utilities.untraced do
+              response = http.request(request)
+              raise "HTTP request failed with status #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+              response.body
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/support/resource_detector/aws/lambda.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry/semantic_conventions/resource'
+
+module OpenTelemetry
+  module Resource
+    module Detector
+      module AWS
+        # Lambda contains detect class method for determining Lambda resource attributes
+        module Lambda
+          extend self
+
+          # Create a constant for resource semantic conventions
+          RESOURCE = ::OpenTelemetry::SemanticConventions::Resource
+
+          def detect
+            # Return empty resource if not running on Lambda
+            return ::OpenTelemetry::SDK::Resources::Resource.create({}) unless lambda_environment?
+
+            resource_attributes = {}
+
+            begin
+              # Set Lambda-specific attributes from environment variables
+              resource_attributes[RESOURCE::CLOUD_PROVIDER] = 'aws'
+              resource_attributes[RESOURCE::CLOUD_PLATFORM] = 'aws_lambda'
+              resource_attributes[RESOURCE::CLOUD_REGION] = ENV.fetch('AWS_REGION', nil)
+              resource_attributes[RESOURCE::FAAS_NAME] = ENV.fetch('AWS_LAMBDA_FUNCTION_NAME', nil)
+              resource_attributes[RESOURCE::FAAS_VERSION] = ENV.fetch('AWS_LAMBDA_FUNCTION_VERSION', nil)
+              resource_attributes[RESOURCE::FAAS_INSTANCE] = ENV.fetch('AWS_LAMBDA_LOG_STREAM_NAME', nil)
+
+              # Convert memory size to integer
+              resource_attributes[RESOURCE::FAAS_MAX_MEMORY] = ENV['AWS_LAMBDA_FUNCTION_MEMORY_SIZE'].to_i if ENV['AWS_LAMBDA_FUNCTION_MEMORY_SIZE']
+            rescue StandardError => e
+              ::OpenTelemetry.handle_error(exception: e, message: 'Lambda resource detection failed')
+              return ::OpenTelemetry::SDK::Resources::Resource.create({})
+            end
+
+            # Filter out nil or empty values
+            # Note: we need to handle integers differently since they don't respond to empty?
+            resource_attributes.delete_if do |_key, value|
+              value.nil? || (value.respond_to?(:empty?) && value.empty?)
+            end
+
+            ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+          end
+
+          private
+
+          # Determines if the current environment is AWS Lambda
+          #
+          # @return [Boolean] true if running on AWS Lambda
+          def lambda_environment?
+            # Check for Lambda-specific environment variables
+            !ENV['AWS_LAMBDA_FUNCTION_NAME'].nil? &&
+              !ENV['AWS_LAMBDA_FUNCTION_VERSION'].nil? &&
+              !ENV['AWS_LAMBDA_LOG_STREAM_NAME'].nil?
+          end
+        end
+      end
+    end
+  end
+end