opentelemetry-config 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6920e5ca17ba99ef990626f22fb6d1d5b09fd0f07a02039c48c7fb420e59d2b
-  data.tar.gz: 3cf56fdd238b6903c3209b150860e5998ad7dbcd26e8e8588b18ea0699115543
+  metadata.gz: e6246820b0b2b5312be2c696c49f6def8f666425b3b5365a44e811fb455a3003
+  data.tar.gz: 38e2b961380f9394cdfa067590e40230e597436d5a349bbc28df3b8aaf58999c
 SHA512:
-  metadata.gz: 677ce312429f98ce5c1555c4d53172ae8ee4fc0c44bff5052844f3afd735d576299306f5d36964afdf1b41d4b115d5c2540a35b7c38d615df33fd8125125e37f
-  data.tar.gz: 60eb6aa2db9e5efec14a2e6c23c2c9fa93d1f6f02ad22998f064836d0a2532ca8b585c8f2a36072f5d52a20093f1eea1b666b9e29d1aec650eb0ec33189363c2
+  metadata.gz: 2dbb1307ce50f1bc2390b1ed90741ae07f74499fade71f1de4540cf5ca930d09e6eca24eb34ca728723a930b3327d0fd9da9b799fb7ad63359e324c9773284cf
+  data.tar.gz: 7e0aa84b67fa17b591343b5cafb9ec58dc5cdff3507dcbbefbfe044bfcbc63f56b8d1603f08317221f759e9a8a0bbf71d2f8ddb93c73a81bd11235386d308d35

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Release History: opentelemetry-config
 
+### v0.2.0 / 2026-10-20
+
+* ADDED: Add declarative configuration for logger_provider (#2439)
+* ADDED: Substitute environment variables in configuration files (#2468)
+* FIXED: Correct schema_url unsupported warning (#2466)
+* FIXED: Parse nullable objects without properties as present (#2465)
+
+### v0.1.1 / 2026-10-13
+
+* FIXED: Ignore SDK env defaults in declarative config (#2429)
+
 ### v0.1.0 / 2026-09-29
 
 * ADDED: Declarative configuration for trace_provider (#2161)

data/README.md

@@ -17,12 +17,13 @@ It works with:
 - `opentelemetry-sdk` — Traces
 - `opentelemetry-exporter-otlp` — OTLP HTTP exporter
 - `opentelemetry-instrumentation-all` — Instrumentation for gems
+- `opentelemetry-logs-sdk` — Logs (optional, see [Logs](#logs))
+- `opentelemetry-exporter-otlp-logs` — OTLP HTTP log exporter (optional)
 
 This code is still under development and is not a complete implementation of the declarative configuration specification. Until the code becomes stable, declarative configuration functionality will live outside stable OpenTelemetry libraries.
 
 Some features we still need to implement include:
 
-- Configuration file precedence over environment variables
 - Using declarative configuration without a call in your code
 - Declarative configuration instrumentation API and SDK
 
@@ -65,6 +66,54 @@ If you have a config file path at hand, call `configure_from_file` instead:
 sdk = OpenTelemetry::Config.configure_from_file('/path/to/otel-config.yaml')
 ```
 
+### Environment variables and SDK-specific settings
+
+File-based configuration uses the values in the YAML file and the schema defaults
+for omitted settings. It does not inherit the SDK's `OTEL_*` environment-variable
+defaults.
+
+To use an environment variable in the file, reference it in a value as
+`${NAME}`, `${env:NAME}`, or `${NAME:-default}`. The default applies when the
+variable is unset or empty. Use `$$` for a literal `$`. Values are typed after
+substitution, so quote a reference to keep it a string.
+
+```yaml
+resource:
+  attributes:
+    - name: service.name
+      value: ${OTEL_SERVICE_NAME:-unknown_service}
+tracer_provider:
+  processors:
+    - batch:
+        exporter:
+          otlp_http:
+            endpoint: ${OTEL_EXPORTER_OTLP_ENDPOINT:-http://localhost:4318}/v1/traces
+```
+
+Some Ruby-specific SDK settings have no equivalent in the configuration schema:
+
+- `OTEL_RUBY_BSP_START_THREAD_ON_BOOT` is ignored. A configured batch span
+  processor starts its worker thread during construction. Applications that need
+  to delay worker startup should use programmatic SDK configuration instead.
+- `OTEL_RUBY_EXPORTER_OTLP_SSL_VERIFY_NONE` and
+  `OTEL_RUBY_EXPORTER_OTLP_SSL_VERIFY_PEER` are ignored. The OTLP HTTP exporter
+  verifies the server certificate. For a private certificate authority, set
+  `tls.ca_file` rather than disabling verification. For mutual TLS, also set
+  `tls.cert_file` and `tls.key_file`.
+
+```yaml
+tracer_provider:
+  processors:
+    - batch:
+        exporter:
+          otlp_http:
+            endpoint: https://collector.example.com:4318/v1/traces
+            tls:
+              ca_file: /path/to/ca.pem
+              cert_file: /path/to/client.pem
+              key_file: /path/to/client-key.pem
+```
+
 ### Parse, create, and install
 
 `configure` is a convenience wrapper around the three [SDK operations][sdk-operations]. Call them individually when you need to inspect the configuration model or delay installing the global state:
@@ -156,6 +205,35 @@ propagator:
 
 Supported propagator names: `tracecontext`, `baggage`, `b3`, `b3multi`, `jaeger`, `ottrace`, `xray`, `google_cloud_trace_context`.
 
+### Logs
+
+Logs support is optional. Add `opentelemetry-logs-sdk` to your Gemfile, along with `opentelemetry-exporter-otlp-logs` if you use the `otlp_http` exporter, and require them before calling `configure`. If a required gem isn't loaded, the logger provider or processor that needs it is skipped with a warning.
+
+```ruby
+require 'opentelemetry-sdk'
+require 'opentelemetry-logs-sdk'
+require 'opentelemetry-exporter-otlp-logs'
+require 'opentelemetry-config'
+```
+
+The configured logger provider is installed as `OpenTelemetry.logger_provider`.
+
+```yaml
+logger_provider:
+  limits:
+    attribute_count_limit: 128
+  processors:
+    - batch:
+        exporter:
+          otlp_http:
+            endpoint: http://localhost:4318/v1/logs
+    - simple:
+        exporter:
+          console:
+```
+
+Supported processors: `batch`, `simple`. Supported exporters: `console`, `otlp_http`.
+
 ## Examples
 
 A runnable example application is available in the [`example/`][example-dir] directory. It demonstrates traces configured from YAML with console output.

data/lib/opentelemetry/config/defaults.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Config
+    # Schema defaults for omitted or null properties. Keys use schema names;
+    # durations are in milliseconds and are converted by the builders.
+    module Defaults
+      BATCH_SPAN_PROCESSOR = {
+        schedule_delay: 5_000,
+        export_timeout: 30_000,
+        max_queue_size: 2048,
+        max_export_batch_size: 512
+      }.freeze
+
+      SPAN_LIMITS = {
+        attribute_count_limit: 128,
+        attribute_value_length_limit: nil,
+        event_count_limit: 128,
+        link_count_limit: 128,
+        event_attribute_count_limit: 128,
+        link_attribute_count_limit: 128
+      }.freeze
+
+      OTLP_HTTP_EXPORTER = {
+        compression: 'none',
+        timeout: 10_000
+      }.freeze
+
+      OTLP_HTTP_TRACES_ENDPOINT = 'http://localhost:4318/v1/traces'
+    end
+
+    private_constant :Defaults
+  end
+end

data/lib/opentelemetry/config/env_substitution.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Config
+    # Loads configuration file YAML with environment variable substitution.
+    #
+    # References of the form +${NAME}+, +${env:NAME}+, and +${NAME:-default}+ are
+    # replaced in scalar values, and +$$+ escapes a literal +$+. Mapping keys are
+    # left untouched. Types are resolved after substitution, so a plain
+    # +${PORT}+ loads as an Integer while a quoted +"${PORT}"+ stays a String.
+    module EnvSubstitution
+      # Raised when a configuration file contains an invalid substitution reference.
+      class Error < StandardError; end
+
+      # A colon followed by "-" starts a default value, not a prefix.
+      REFERENCE = /\$\{(?:(?<prefix>[a-zA-Z][a-zA-Z0-9_]*):(?!-))?(?<content>[^}]+)\}/
+      ENV_REFERENCE = /\A(?<name>[a-zA-Z_][a-zA-Z0-9_]*)(?::-(?<default>[^\n]*))?\z/
+      PERMITTED_CLASSES = %w[Date Time].freeze
+      private_constant :REFERENCE, :ENV_REFERENCE, :PERMITTED_CLASSES
+
+      module_function
+
+      # Parses YAML and substitutes environment variables in its scalar values.
+      #
+      # @param content [String] YAML document
+      # @param env [Hash{String => String}] environment variables to substitute
+      # @return [Object, nil] the loaded document, or nil when it is empty
+      # @raise [Error] when a substitution reference is invalid
+      # @raise [Psych::Exception] when the YAML is invalid or uses a disallowed
+      #   class or alias
+      def load(content, env = ENV)
+        document = Psych.parse(content)
+        return unless document
+
+        substitute_node(document, env)
+
+        class_loader = Psych::ClassLoader::Restricted.new(PERMITTED_CLASSES, [])
+        scanner = Psych::ScalarScanner.new(class_loader)
+        Psych::Visitors::NoAliasRuby.new(scanner, class_loader).accept(document)
+      end
+
+      # Substitutes environment variable references in a string.
+      #
+      # @param value [String]
+      # @param env [Hash{String => String}] environment variables to substitute
+      # @return [String]
+      # @raise [Error] when a substitution reference is invalid
+      def substitute(value, env = ENV)
+        # Split on escapes first so a "$" they produce never starts a reference.
+        value.split('$$', -1).map do |segment|
+          segment.gsub(REFERENCE) { resolve(Regexp.last_match, env) }
+        end.join('$')
+      end
+
+      # Substitutes scalar values in a node tree, skipping mapping keys.
+      def substitute_node(node, env)
+        case node
+        when Psych::Nodes::Scalar
+          node.value = substitute(node.value, env)
+        when Psych::Nodes::Mapping
+          node.children.each_slice(2) { |_key, value| substitute_node(value, env) }
+        else
+          Array(node.children).each { |child| substitute_node(child, env) }
+        end
+      end
+
+      # Returns the replacement for a matched reference.
+      def resolve(match, env)
+        reference = ENV_REFERENCE.match(match[:content]) if match[:prefix].nil? || match[:prefix] == 'env'
+        raise Error, "invalid substitution reference #{match[0]}" unless reference
+
+        value = env[reference[:name]]
+        return value unless value.nil? || value.empty?
+
+        reference[:default].to_s
+      end
+      private_class_method :substitute_node, :resolve
+    end
+  end
+end

data/lib/opentelemetry/config/generated_constants.rb

@@ -12,6 +12,15 @@ module OpenTelemetry
   module Config
     # Generated struct definitions mirroring the OpenTelemetry configuration schema.
     module Model
+      # Parses the nullable object at +key+ with +klass+. An explicit null
+      # parses as an object with every property omitted.
+      def self.nullable_from_hash(klass, h, key)
+        return nil unless h.key?(key)
+
+        value = h[key]
+        klass.from_hash(value.nil? ? {} : value)
+      end
+
       Aggregation = Struct.new(
         :default,
         :drop,
@@ -27,8 +36,8 @@ module OpenTelemetry
           new(
             default: h.key?('default'),
             drop: h.key?('drop'),
-            explicit_bucket_histogram: ExplicitBucketHistogramAggregation.from_hash(h['explicit_bucket_histogram']),
-            base2_exponential_bucket_histogram: Base2ExponentialBucketHistogramAggregation.from_hash(h['base2_exponential_bucket_histogram']),
+            explicit_bucket_histogram: Model.nullable_from_hash(ExplicitBucketHistogramAggregation, h, 'explicit_bucket_histogram'),
+            base2_exponential_bucket_histogram: Model.nullable_from_hash(Base2ExponentialBucketHistogramAggregation, h, 'base2_exponential_bucket_histogram'),
             last_value: h.key?('last_value'),
             sum: h.key?('sum')
           )
@@ -276,8 +285,8 @@ module OpenTelemetry
             always_off: h.key?('always_off'),
             always_on: h.key?('always_on'),
             parent_threshold: ExperimentalComposableParentThresholdSampler.from_hash(h['parent_threshold']),
-            probability: ExperimentalComposableProbabilitySampler.from_hash(h['probability']),
-            rule_based: ExperimentalComposableRuleBasedSampler.from_hash(h['rule_based']),
+            probability: Model.nullable_from_hash(ExperimentalComposableProbabilitySampler, h, 'probability'),
+            rule_based: Model.nullable_from_hash(ExperimentalComposableRuleBasedSampler, h, 'rule_based'),
             additional_properties: h.except('always_off', 'always_on', 'parent_threshold', 'probability', 'rule_based')
           )
         end
@@ -736,9 +745,9 @@ module OpenTelemetry
           return nil unless h.is_a?(Hash)
 
           new(
-            otlp_http: OtlpHttpExporter.from_hash(h['otlp_http']),
-            otlp_grpc: OtlpGrpcExporter.from_hash(h['otlp_grpc']),
-            otlp_file_development: ExperimentalOtlpFileExporter.from_hash(h['otlp_file/development']),
+            otlp_http: Model.nullable_from_hash(OtlpHttpExporter, h, 'otlp_http'),
+            otlp_grpc: Model.nullable_from_hash(OtlpGrpcExporter, h, 'otlp_grpc'),
+            otlp_file_development: Model.nullable_from_hash(ExperimentalOtlpFileExporter, h, 'otlp_file/development'),
             console: h.key?('console'),
             additional_properties: h.except('otlp_http', 'otlp_grpc', 'otlp_file/development', 'console')
           )
@@ -907,7 +916,7 @@ module OpenTelemetry
 
           new(
             endpoint: h['endpoint'],
-            tls: GrpcTls.from_hash(h['tls']),
+            tls: Model.nullable_from_hash(GrpcTls, h, 'tls'),
             headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
             headers_list: h['headers_list'],
             compression: h['compression'],
@@ -932,7 +941,7 @@ module OpenTelemetry
 
           new(
             endpoint: h['endpoint'],
-            tls: GrpcTls.from_hash(h['tls']),
+            tls: Model.nullable_from_hash(GrpcTls, h, 'tls'),
             headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
             headers_list: h['headers_list'],
             compression: h['compression'],
@@ -958,7 +967,7 @@ module OpenTelemetry
 
           new(
             endpoint: h['endpoint'],
-            tls: HttpTls.from_hash(h['tls']),
+            tls: Model.nullable_from_hash(HttpTls, h, 'tls'),
             headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
             headers_list: h['headers_list'],
             compression: h['compression'],
@@ -985,7 +994,7 @@ module OpenTelemetry
 
           new(
             endpoint: h['endpoint'],
-            tls: HttpTls.from_hash(h['tls']),
+            tls: Model.nullable_from_hash(HttpTls, h, 'tls'),
             headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
             headers_list: h['headers_list'],
             compression: h['compression'],
@@ -1063,7 +1072,7 @@ module OpenTelemetry
           return nil unless h.is_a?(Hash)
 
           new(
-            prometheus_development: ExperimentalPrometheusMetricExporter.from_hash(h['prometheus/development']),
+            prometheus_development: Model.nullable_from_hash(ExperimentalPrometheusMetricExporter, h, 'prometheus/development'),
             additional_properties: h.except('prometheus/development')
           )
         end
@@ -1098,10 +1107,10 @@ module OpenTelemetry
           return nil unless h.is_a?(Hash)
 
           new(
-            otlp_http: OtlpHttpMetricExporter.from_hash(h['otlp_http']),
-            otlp_grpc: OtlpGrpcMetricExporter.from_hash(h['otlp_grpc']),
-            otlp_file_development: ExperimentalOtlpFileMetricExporter.from_hash(h['otlp_file/development']),
-            console: ConsoleMetricExporter.from_hash(h['console']),
+            otlp_http: Model.nullable_from_hash(OtlpHttpMetricExporter, h, 'otlp_http'),
+            otlp_grpc: Model.nullable_from_hash(OtlpGrpcMetricExporter, h, 'otlp_grpc'),
+            otlp_file_development: Model.nullable_from_hash(ExperimentalOtlpFileMetricExporter, h, 'otlp_file/development'),
+            console: Model.nullable_from_hash(ConsoleMetricExporter, h, 'console'),
             additional_properties: h.except('otlp_http', 'otlp_grpc', 'otlp_file/development', 'console')
           )
         end
@@ -1144,10 +1153,10 @@ module OpenTelemetry
             always_off: h.key?('always_off'),
             always_on: h.key?('always_on'),
             composite_development: ExperimentalComposableSampler.from_hash(h['composite/development']),
-            jaeger_remote_development: ExperimentalJaegerRemoteSampler.from_hash(h['jaeger_remote/development']),
-            parent_based: ParentBasedSampler.from_hash(h['parent_based']),
-            probability_development: ExperimentalProbabilitySampler.from_hash(h['probability/development']),
-            trace_id_ratio_based: TraceIdRatioBasedSampler.from_hash(h['trace_id_ratio_based']),
+            jaeger_remote_development: Model.nullable_from_hash(ExperimentalJaegerRemoteSampler, h, 'jaeger_remote/development'),
+            parent_based: Model.nullable_from_hash(ParentBasedSampler, h, 'parent_based'),
+            probability_development: Model.nullable_from_hash(ExperimentalProbabilitySampler, h, 'probability/development'),
+            trace_id_ratio_based: Model.nullable_from_hash(TraceIdRatioBasedSampler, h, 'trace_id_ratio_based'),
             additional_properties: h.except('always_off', 'always_on', 'composite/development', 'jaeger_remote/development', 'parent_based', 'probability/development', 'trace_id_ratio_based')
           )
         end
@@ -1191,9 +1200,9 @@ module OpenTelemetry
           return nil unless h.is_a?(Hash)
 
           new(
-            otlp_http: OtlpHttpExporter.from_hash(h['otlp_http']),
-            otlp_grpc: OtlpGrpcExporter.from_hash(h['otlp_grpc']),
-            otlp_file_development: ExperimentalOtlpFileExporter.from_hash(h['otlp_file/development']),
+            otlp_http: Model.nullable_from_hash(OtlpHttpExporter, h, 'otlp_http'),
+            otlp_grpc: Model.nullable_from_hash(OtlpGrpcExporter, h, 'otlp_grpc'),
+            otlp_file_development: Model.nullable_from_hash(ExperimentalOtlpFileExporter, h, 'otlp_file/development'),
             console: h.key?('console'),
             additional_properties: h.except('otlp_http', 'otlp_grpc', 'otlp_file/development', 'console')
           )

data/lib/opentelemetry/config/logs.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Config
+    # Logs component builder for configuring LoggerProvider from declarative config.
+    module Logs
+      module_function
+
+      # Builds a LoggerProvider from the parsed YAML logger_provider config.
+      # Returns nil if config is nil or opentelemetry-logs-sdk isn't loaded.
+      def build_logger_provider(config, resource)
+        return unless config
+
+        unless defined?(OpenTelemetry::SDK::Logs::LoggerProvider)
+          OpenTelemetry.logger.warn('logger_provider is configured but opentelemetry-logs-sdk is not loaded. ' \
+                                    'Add `gem "opentelemetry-logs-sdk"` to your Gemfile.')
+          return
+        end
+
+        lp = OpenTelemetry::SDK::Logs::LoggerProvider.new(
+          resource: resource,
+          log_record_limits: build_log_record_limits(config.limits)
+        )
+
+        Array(config.processors).each do |proc_cfg|
+          lp.add_log_record_processor(build_log_record_processor(proc_cfg))
+        rescue StandardError => e
+          OpenTelemetry.logger.warn("Failed to build log record processor: #{e.message}")
+        end
+
+        lp
+      end
+
+      # Builds a log record processor (simple or batch) from config.
+      def build_log_record_processor(proc_cfg)
+        raise ArgumentError, 'must not specify multiple log record processor types' if proc_cfg.batch && proc_cfg.simple
+
+        if proc_cfg.batch
+          build_batch_log_record_processor(proc_cfg.batch)
+        elsif proc_cfg.simple
+          build_simple_log_record_processor(proc_cfg.simple)
+        else
+          raise ArgumentError, 'unsupported log record processor type, must be one of simple or batch'
+        end
+      end
+
+      # Builds a BatchLogRecordProcessor with exporter and optional tuning options.
+      def build_batch_log_record_processor(cfg)
+        exporter = build_log_record_exporter(cfg.exporter)
+        opts = {
+          schedule_delay: cfg.schedule_delay&.to_f,
+          exporter_timeout: cfg.export_timeout&.to_f,
+          max_queue_size: cfg.max_queue_size&.to_i,
+          max_export_batch_size: cfg.max_export_batch_size&.to_i
+        }.compact
+
+        OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(exporter, **opts)
+      end
+
+      # Builds a SimpleLogRecordProcessor wrapping the configured exporter.
+      def build_simple_log_record_processor(cfg)
+        OpenTelemetry::SDK::Logs::Export::SimpleLogRecordProcessor.new(build_log_record_exporter(cfg.exporter))
+      end
+
+      # Builds a log record exporter from config; supports console and otlp_http.
+      def build_log_record_exporter(exp_cfg)
+        raise ArgumentError, 'no exporter config' unless exp_cfg
+
+        configured = 0
+        exporter   = nil
+
+        if exp_cfg.console
+          configured += 1
+          exporter = OpenTelemetry::SDK::Logs::Export::ConsoleLogRecordExporter.new
+        end
+
+        if exp_cfg.otlp_http
+          configured += 1
+          exporter = build_otlp_http_log_record_exporter(exp_cfg.otlp_http)
+        end
+
+        raise ArgumentError, 'must not specify multiple exporters' if configured > 1
+        raise ArgumentError, 'no valid log record exporter'        if exporter.nil?
+
+        exporter
+      end
+
+      # Builds an OTLP HTTP log record exporter from the given endpoint, headers, and TLS config.
+      def build_otlp_http_log_record_exporter(cfg)
+        unless defined?(OpenTelemetry::Exporter::OTLP::Logs::LogsExporter)
+          raise ArgumentError, 'otlp_http requires opentelemetry-exporter-otlp-logs. ' \
+                               'Add `gem "opentelemetry-exporter-otlp-logs"` to your Gemfile.'
+        end
+
+        headers = Trace.headers_to_hash(cfg)
+        opts = {
+          endpoint: cfg.endpoint,
+          certificate_file: cfg.tls&.ca_file,
+          client_certificate_file: cfg.tls&.cert_file,
+          client_key_file: cfg.tls&.key_file,
+          headers: headers.empty? ? nil : headers,
+          compression: cfg.compression,
+          timeout: cfg.timeout && (cfg.timeout / 1000.0)
+        }.compact
+
+        OpenTelemetry::Exporter::OTLP::Logs::LogsExporter.new(**opts)
+      end
+
+      # Builds LogRecordLimits from config; returns the SDK default when config is nil.
+      def build_log_record_limits(limits_cfg)
+        return OpenTelemetry::SDK::Logs::LogRecordLimits::DEFAULT unless limits_cfg
+
+        opts = {
+          attribute_count_limit: limits_cfg.attribute_count_limit,
+          attribute_length_limit: limits_cfg.attribute_value_length_limit
+        }.compact
+
+        OpenTelemetry::SDK::Logs::LogRecordLimits.new(**opts)
+      end
+    end
+
+    private_constant :Logs
+  end
+end

data/lib/opentelemetry/config/resource.rb

@@ -11,7 +11,7 @@ module OpenTelemetry
 
       # Priority: attributes > attribute_list > detected > base
       def build_resource(resource_cfg)
-        base = OpenTelemetry::SDK::Resources::Resource.default
+        base = default_resource
 
         return base unless resource_cfg
 
@@ -31,13 +31,27 @@ module OpenTelemetry
           end
         end
 
-        OpenTelemetry.logger.warn('Config: schema_url is supported; ignoring.') if resource_cfg.schema_url
+        OpenTelemetry.logger.warn('Config: schema_url is not supported; ignoring.') if resource_cfg.schema_url
 
         attrs = detected.merge(explicit)
         custom = OpenTelemetry::SDK::Resources::Resource.create(attrs)
         base.merge(custom)
       end
 
+      # Builds the intrinsic SDK resource without consulting OTEL_* environment
+      # variables. File-based configuration and environment configuration are
+      # intentionally separate sources.
+      def default_resource
+        resource_class = OpenTelemetry::SDK::Resources::Resource
+
+        resource_class.create(
+          OpenTelemetry::SemanticConventions::Resource::SERVICE_NAME => 'unknown_service',
+          OpenTelemetry::SemanticConventions::Resource::TELEMETRY_SDK_NAME => 'opentelemetry',
+          OpenTelemetry::SemanticConventions::Resource::TELEMETRY_SDK_LANGUAGE => 'ruby',
+          OpenTelemetry::SemanticConventions::Resource::TELEMETRY_SDK_VERSION => OpenTelemetry::SDK::VERSION
+        ).merge(resource_class.process)
+      end
+
       # type coercion
       def coerce_attribute_value(value, type)
         case type

data/lib/opentelemetry/config/trace.rb

@@ -3,6 +3,8 @@
 # Copyright The OpenTelemetry Authors
 # SPDX-License-Identifier: Apache-2.0
 
+require 'openssl'
+
 module OpenTelemetry
   module Config
     # Trace component builder for configuring TracerProvider from declarative config.
@@ -46,15 +48,17 @@ module OpenTelemetry
         end
       end
 
-      # Builds a BatchSpanProcessor with exporter and optional tuning options.
+      # Builds a BatchSpanProcessor with exporter and schema defaults. Passing
+      # environment-backed options explicitly prevents it from reading OTEL_*.
       def build_batch_span_processor(cfg)
         exporter = build_span_exporter(cfg.exporter)
         opts = {
-          schedule_delay: cfg.schedule_delay&.to_f,
-          exporter_timeout: cfg.export_timeout&.to_f,
-          max_queue_size: cfg.max_queue_size&.to_i,
-          max_export_batch_size: cfg.max_export_batch_size&.to_i
-        }.compact
+          schedule_delay: (cfg.schedule_delay || Defaults::BATCH_SPAN_PROCESSOR[:schedule_delay]).to_f,
+          exporter_timeout: (cfg.export_timeout || Defaults::BATCH_SPAN_PROCESSOR[:export_timeout]).to_f,
+          max_queue_size: (cfg.max_queue_size || Defaults::BATCH_SPAN_PROCESSOR[:max_queue_size]).to_i,
+          max_export_batch_size: (cfg.max_export_batch_size || Defaults::BATCH_SPAN_PROCESSOR[:max_export_batch_size]).to_i,
+          start_thread_on_boot: true
+        }
 
         OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(exporter, **opts)
       end
@@ -88,17 +92,19 @@ module OpenTelemetry
         exporter
       end
 
-      # Builds an OTLP HTTP span exporter from the given endpoint/headers config.
+      # Builds an OTLP HTTP span exporter from declarative values and schema
+      # defaults, without falling back to exporter environment variables.
       def build_otlp_http_span_exporter(cfg)
-        headers = headers_to_hash(cfg)
-        opts = {
-          endpoint: cfg.endpoint,
-          headers: headers.empty? ? nil : headers,
-          compression: cfg.compression,
-          timeout: cfg.timeout && (cfg.timeout / 1000.0) # YAML ms → Ruby seconds
-        }.compact
-
-        OpenTelemetry::Exporter::OTLP::Exporter.new(**opts)
+        OpenTelemetry::Exporter::OTLP::Exporter.new(
+          endpoint: cfg.endpoint || Defaults::OTLP_HTTP_TRACES_ENDPOINT,
+          certificate_file: cfg.tls&.ca_file,
+          client_certificate_file: cfg.tls&.cert_file,
+          client_key_file: cfg.tls&.key_file,
+          ssl_verify_mode: OpenSSL::SSL::VERIFY_PEER,
+          headers: headers_to_hash(cfg),
+          compression: cfg.compression || Defaults::OTLP_HTTP_EXPORTER[:compression],
+          timeout: (cfg.timeout || Defaults::OTLP_HTTP_EXPORTER[:timeout]) / 1000.0
+        )
       end
 
       # Builds a sampler from config; defaults to ParentBased(ALWAYS_ON).
@@ -139,20 +145,17 @@ module OpenTelemetry
         s.parent_based(**opts)
       end
 
-      # Builds SpanLimits from config; returns the SDK default when config is nil.
+      # Builds SpanLimits from declarative values and schema defaults.
       def build_span_limits(limits_cfg)
-        return OpenTelemetry::SDK::Trace::SpanLimits::DEFAULT unless limits_cfg
-
-        opts = {
-          attribute_count_limit: limits_cfg.attribute_count_limit,
-          attribute_length_limit: limits_cfg.attribute_value_length_limit,
-          event_count_limit: limits_cfg.event_count_limit,
-          link_count_limit: limits_cfg.link_count_limit,
-          event_attribute_count_limit: limits_cfg.event_attribute_count_limit,
-          link_attribute_count_limit: limits_cfg.link_attribute_count_limit
-        }.compact
-
-        OpenTelemetry::SDK::Trace::SpanLimits.new(**opts)
+        OpenTelemetry::SDK::Trace::SpanLimits.new(
+          attribute_count_limit: limits_cfg&.attribute_count_limit || Defaults::SPAN_LIMITS[:attribute_count_limit],
+          attribute_length_limit: limits_cfg&.attribute_value_length_limit || Defaults::SPAN_LIMITS[:attribute_value_length_limit],
+          event_count_limit: limits_cfg&.event_count_limit || Defaults::SPAN_LIMITS[:event_count_limit],
+          link_count_limit: limits_cfg&.link_count_limit || Defaults::SPAN_LIMITS[:link_count_limit],
+          event_attribute_count_limit: limits_cfg&.event_attribute_count_limit || Defaults::SPAN_LIMITS[:event_attribute_count_limit],
+          event_attribute_length_limit: nil,
+          link_attribute_count_limit: limits_cfg&.link_attribute_count_limit || Defaults::SPAN_LIMITS[:link_attribute_count_limit]
+        )
       end
 
       # Converts the OTLP exporter headers (array of NameStringValuePair structs)

data/lib/opentelemetry/config/version.rb

@@ -5,6 +5,6 @@
 
 module OpenTelemetry
   module Config
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/opentelemetry/config.rb

@@ -6,6 +6,9 @@
 require 'date'
 require 'yaml'
 
+require_relative 'config/defaults'
+require_relative 'config/env_substitution'
+require_relative 'config/logs'
 require_relative 'config/propagation'
 require_relative 'config/resource'
 require_relative 'config/constants'
@@ -47,13 +50,16 @@ module OpenTelemetry
         end
 
         content = File.read(path)
-        OpenTelemetry::Config::Model::OpenTelemetryConfiguration.from_hash(YAML.safe_load(content, permitted_classes: [Date, Time]))
+        OpenTelemetry::Config::Model::OpenTelemetryConfiguration.from_hash(EnvSubstitution.load(content))
       rescue Errno::ENOENT => e
         OpenTelemetry.logger.error("Config file not found: #{e.message}")
         nil
       rescue Psych::SyntaxError => e
         OpenTelemetry.logger.error("YAML parse error: #{e.message}")
         nil
+      rescue EnvSubstitution::Error => e
+        OpenTelemetry.logger.error("Config file substitution error: #{e.message}")
+        nil
       end
 
       # Creates the components described by a configuration model without
@@ -80,11 +86,13 @@ module OpenTelemetry
 
         # tracer_provider will be noop if opentelemetry-sdk is not installed
         tracer_provider = Trace.build_tracer_provider(config.tracer_provider, resource)
+        logger_provider = Logs.build_logger_provider(config.logger_provider, resource)
 
         propagators = configure_propagation(config.propagator)
 
         RubySDK.new(
           tracer_provider: tracer_provider,
+          logger_provider: logger_provider,
           propagator: propagators,
           resource: resource
         )
@@ -99,9 +107,21 @@ module OpenTelemetry
         return ruby_sdk if ruby_sdk.equal?(NOOP_SDK)
 
         OpenTelemetry.tracer_provider = ruby_sdk.tracer_provider if ruby_sdk.tracer_provider
+        install_logger_provider(ruby_sdk.logger_provider) if ruby_sdk.logger_provider
         OpenTelemetry.propagation = ruby_sdk.propagator if ruby_sdk.propagator
         ruby_sdk
       end
+
+      private
+
+      def install_logger_provider(provider)
+        if OpenTelemetry.respond_to?(:logger_provider=)
+          OpenTelemetry.logger_provider = provider
+        else
+          OpenTelemetry.logger.warn('Cannot install the configured logger provider: OpenTelemetry.logger_provider= ' \
+                                    'is not defined. Require opentelemetry-logs-sdk.')
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-config
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.34.1
+        version: '0.34'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.34.1
+        version: '0.34'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-sdk
   requirement: !ruby/object:Gem::Requirement
@@ -78,7 +78,10 @@ files:
 - lib/opentelemetry-config.rb
 - lib/opentelemetry/config.rb
 - lib/opentelemetry/config/constants.rb
+- lib/opentelemetry/config/defaults.rb
+- lib/opentelemetry/config/env_substitution.rb
 - lib/opentelemetry/config/generated_constants.rb
+- lib/opentelemetry/config/logs.rb
 - lib/opentelemetry/config/propagation.rb
 - lib/opentelemetry/config/resource.rb
 - lib/opentelemetry/config/trace.rb
@@ -87,10 +90,10 @@ homepage: https://github.com/open-telemetry/opentelemetry-ruby
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-config/0.1.0/file/CHANGELOG.md
-  source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby/tree/opentelemetry-config/v0.1.0/config
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-config/0.2.0/file/CHANGELOG.md
+  source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby/tree/opentelemetry-config/v0.2.0/config
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-config/0.1.0
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-config/0.2.0
 rdoc_options: []
 require_paths:
 - lib