solarwinds_apm 6.1.1 → 7.0.0.prev1

data/lib/solarwinds_apm/{noop/span.rb → support/aws_resource_detector.rb}

@@ -1,25 +1,12 @@
 # frozen_string_literal: true
 
-# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
+# © 2025 SolarWinds Worldwide, LLC. All rights reserved.
 #
 # Licensed 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.
 
-####
-# noop version of SolarWindsAPM::Span
-#
-module Oboe_metal # rubocop:disable Naming/ClassAndModuleCamelCase
-  # Span
-  class Span
-    ##
-    # noop version of :createHttpSpan
-    #
-    def self.createHttpSpan(*); end
-
-    ##
-    # noop version of :createSpan
-    #
-    def self.createSpan(*); end
-  end
-end
+require_relative 'resource_detector/aws/ecs'
+require_relative 'resource_detector/aws/eks'
+require_relative 'resource_detector/aws/lambda'
+require_relative 'resource_detector/aws/beanstalk'

data/lib/solarwinds_apm/support/logger_formatter.rb

@@ -47,4 +47,4 @@ end
 
 # To use the trace context in log, ::Logger::Formatter.new must be defined
 # e.g. config.log_formatter = ::Logger::Formatter.new
-Logger::Formatter.prepend(SolarWindsAPM::Logger::Formatter) if SolarWindsAPM.loaded
+Logger::Formatter.prepend(SolarWindsAPM::Logger::Formatter)

data/lib/solarwinds_apm/support/logging_log_event.rb

@@ -23,4 +23,4 @@ module SolarWindsAPM
   end
 end
 
-Logging::LogEvent.prepend(SolarWindsAPM::Logging::LogEvent) if SolarWindsAPM.loaded && defined?(Logging::LogEvent)
+Logging::LogEvent.prepend(SolarWindsAPM::Logging::LogEvent) if defined?(Logging::LogEvent)

data/lib/solarwinds_apm/support/lumberjack_formatter.rb

@@ -23,4 +23,4 @@ module SolarWindsAPM
   end
 end
 
-Lumberjack::LogEntry.prepend(SolarWindsAPM::Lumberjack::LogEntry) if SolarWindsAPM.loaded && defined?(Lumberjack::LogEntry)
+Lumberjack::LogEntry.prepend(SolarWindsAPM::Lumberjack::LogEntry) if defined?(Lumberjack::LogEntry)

data/lib/solarwinds_apm/support/otlp_endpoint.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
+#
+# Licensed 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.
+
+require_relative 'service_key_checker'
+
+module SolarWindsAPM
+  # OTLPEndPoint
+  class OTLPEndPoint
+    attr_reader :token, :service_name
+
+    SWO_APM_ENDPOINT_REGEX = /^apm\.collector\.([a-z]{2}-\d{2})\.([^.]+)\.solarwinds\.com(?::\d+)?$/
+    SWO_APM_ENDPOINT_DEFAULT = 'apm.collector.na-01.cloud.solarwinds.com:443'
+
+    SWO_OTLP_GENERAL_ENDPOINT_REGEX = %r{^https://otel\.collector\.[a-z0-9-]+\.[a-z0-9-]+\.solarwinds\.com(?::\d+)?$}
+    SWO_OTLP_SIGNAL_ENDPOINT_REGEX = %r{^https://otel\.collector\.[a-z0-9-]+\.[a-z0-9-]+\.solarwinds\.com(?::\d+)?/v1/(?:logs|metrics|traces)$}
+    SWO_OTLP_ENDPOINT_DEFAULT = 'https://otel.collector.na-01.cloud.solarwinds.com:443'
+
+    OTEL_SIGNAL_TYPE = %w[TRACES METRICS LOGS].freeze
+
+    def initialize
+      @token = nil
+      @service_name = nil
+    end
+
+    def config_otlp_token_and_endpoint
+      matches = ENV['SW_APM_COLLECTOR'].to_s.match(SWO_APM_ENDPOINT_REGEX)
+
+      resolve_get_setting_endpoint(matches)
+
+      service_key_checker = SolarWindsAPM::ServiceKeyChecker.new('ssl', SolarWindsAPM::Utils.determine_lambda)
+      @token = service_key_checker.token
+      @service_name = service_key_checker.service_name
+
+      OTEL_SIGNAL_TYPE.each do |data_type|
+        config_token(data_type)
+        configure_otlp_endpoint(data_type, matches)
+      end
+    end
+
+    # APM Libraries should only set the bearer token header as a convenience if:
+    # The OTEL config for exporter OTLP headers is not already set, i.e. explicitly configured by the end user, AND
+    # The OTLP export endpoint is SWO, i.e. host is otel.collector.*.*.solarwinds.com
+    def config_token(data_type)
+      data_type_upper = data_type.upcase
+
+      return unless @token
+
+      if ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_HEADERS"].to_s.empty? && ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"].to_s.match?(SWO_OTLP_SIGNAL_ENDPOINT_REGEX)
+        ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_HEADERS"] = "authorization=Bearer #{@token}"
+      elsif ENV['OTEL_EXPORTER_OTLP_HEADERS'].to_s.empty? && ENV['OTEL_EXPORTER_OTLP_ENDPOINT'].to_s.match?(SWO_OTLP_GENERAL_ENDPOINT_REGEX)
+        ENV['OTEL_EXPORTER_OTLP_HEADERS'] = "authorization=Bearer #{@token}"
+      end
+
+      ENV['OTEL_EXPORTER_OTLP_HEADERS'] = "authorization=Bearer #{@token}" if ENV['OTEL_EXPORTER_OTLP_HEADERS'].to_s.empty? && ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_HEADERS"].to_s.empty?
+    end
+
+    def configure_otlp_endpoint(data_type, matches)
+      data_type_upper = data_type.upcase
+      data_type_lower = data_type.downcase
+      otlp_endpoint_source = if ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"]
+                               "#{data_type_lower}_endpoint"
+                             elsif ENV['OTEL_EXPORTER_OTLP_ENDPOINT']
+                               'general_endpoint'
+                             else
+                               'no_endpoint'
+                             end
+
+      SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] otlp_endpoint_source: #{otlp_endpoint_source}" }
+
+      return unless otlp_endpoint_source == 'no_endpoint'
+
+      if matches&.size == 3
+        region = matches[1]
+        env    = matches[2]
+        ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"] = "https://otel.collector.#{region}.#{env}.solarwinds.com:443/v1/#{data_type_lower}"
+      else
+        ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"] = "https://otel.collector.na-01.cloud.solarwinds.com:443/v1/#{data_type_lower}"
+      end
+    end
+
+    # only valid value is apm.collector.*.*.solarwinds.com
+    # If SW APM config for collector is not set, the fallback: apm.collector.na-01.cloud.solarwinds.com
+    def resolve_get_setting_endpoint(matches)
+      return if matches&.size == 3
+
+      unless ENV['SW_APM_COLLECTOR'].to_s.empty?
+        SolarWindsAPM.logger.warn do
+          "[#{self.class}/#{__method__}] SW_APM_COLLECTOR format invalid: #{ENV.fetch('SW_APM_COLLECTOR', nil)}. Valid format: apm.collector.*.*.solarwinds.com"
+        end
+      end
+      ENV['SW_APM_COLLECTOR'] = SWO_APM_ENDPOINT_DEFAULT
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
+#
+# Licensed 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.
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'socket'
+
+module SolarWindsAPM
+  module ResourceDetector
+    # Beanstalk
+    module Beanstalk
+      module_function
+
+      DEFAULT_BEANSTALK_CONF_PATH = '/var/elasticbeanstalk/xray/environment.conf'
+      WIN_OS_BEANSTALK_CONF_PATH = 'C:\\Program Files\\Amazon\\XRay\\environment.conf'
+
+      def detect
+        beanstalk_config_path = if RUBY_PLATFORM.include?('mingw32') || RUBY_PLATFORM.include?('mswin')
+                                  WIN_OS_BEANSTALK_CONF_PATH
+                                else
+                                  DEFAULT_BEANSTALK_CONF_PATH
+                                end
+
+        attribute = gather_data(beanstalk_config_path)
+        ::OpenTelemetry::SDK::Resources::Resource.create(attribute)
+      end
+
+      def gather_data(config_path)
+        raw_data = File.read(config_path, encoding: 'utf-8')
+        parsed_data = JSON.parse(raw_data)
+        {
+          ::OpenTelemetry::SemanticConventions::Resource::CLOUD_PROVIDER => 'aws',
+          ::OpenTelemetry::SemanticConventions::Resource::CLOUD_PLATFORM => 'aws_elastic_beanstalk',
+          ::OpenTelemetry::SemanticConventions::Resource::SERVICE_NAME => 'aws_elastic_beanstalk',
+          ::OpenTelemetry::SemanticConventions::Resource::SERVICE_NAMESPACE => parsed_data['environment_name'],
+          ::OpenTelemetry::SemanticConventions::Resource::SERVICE_VERSION => parsed_data['version_label'],
+          ::OpenTelemetry::SemanticConventions::Resource::SERVICE_INSTANCE_ID => parsed_data['deployment_id']
+        }
+      rescue StandardError => e
+        SolarWindsAPM.logger.debug { "Gather data for AWS Elastic Beanstalk resource detector failed: #{e.message}" }
+        {}
+      end
+    end
+  end
+end

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