opentelemetry-config 0.1.0

data/lib/opentelemetry/config/generated_constants.rb

@@ -0,0 +1,1360 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+#
+# DO NOT EDIT — generated by `bundle exec rake generate:constants`
+# Schema: open-telemetry/opentelemetry-configuration v1.0.0-rc.3
+# Structs: 74 (one per object definition in the schema)
+# To regenerate: bundle exec rake generate:constants
+
+module OpenTelemetry
+  module Config
+    # Generated struct definitions mirroring the OpenTelemetry configuration schema.
+    module Model
+      Aggregation = Struct.new(
+        :default,
+        :drop,
+        :explicit_bucket_histogram,
+        :base2_exponential_bucket_histogram,
+        :last_value,
+        :sum,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          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']),
+            last_value: h.key?('last_value'),
+            sum: h.key?('sum')
+          )
+        end
+      end
+
+      AttributeLimits = Struct.new(
+        :attribute_value_length_limit,
+        :attribute_count_limit,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            attribute_value_length_limit: h['attribute_value_length_limit'],
+            attribute_count_limit: h['attribute_count_limit']
+          )
+        end
+      end
+
+      AttributeNameValue = Struct.new(
+        :name,
+        :value,
+        :type,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            name: h['name'],
+            value: h['value'],
+            type: h['type']
+          )
+        end
+      end
+
+      Base2ExponentialBucketHistogramAggregation = Struct.new(
+        :max_scale,
+        :max_size,
+        :record_min_max,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            max_scale: h['max_scale'],
+            max_size: h['max_size'],
+            record_min_max: h['record_min_max']
+          )
+        end
+      end
+
+      BatchLogRecordProcessor = Struct.new(
+        :schedule_delay,
+        :export_timeout,
+        :max_queue_size,
+        :max_export_batch_size,
+        :exporter,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            schedule_delay: h['schedule_delay'],
+            export_timeout: h['export_timeout'],
+            max_queue_size: h['max_queue_size'],
+            max_export_batch_size: h['max_export_batch_size'],
+            exporter: LogRecordExporter.from_hash(h['exporter'])
+          )
+        end
+      end
+
+      BatchSpanProcessor = Struct.new(
+        :schedule_delay,
+        :export_timeout,
+        :max_queue_size,
+        :max_export_batch_size,
+        :exporter,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            schedule_delay: h['schedule_delay'],
+            export_timeout: h['export_timeout'],
+            max_queue_size: h['max_queue_size'],
+            max_export_batch_size: h['max_export_batch_size'],
+            exporter: SpanExporter.from_hash(h['exporter'])
+          )
+        end
+      end
+
+      CardinalityLimits = Struct.new(
+        :default,
+        :counter,
+        :gauge,
+        :histogram,
+        :observable_counter,
+        :observable_gauge,
+        :observable_up_down_counter,
+        :up_down_counter,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            default: h['default'],
+            counter: h['counter'],
+            gauge: h['gauge'],
+            histogram: h['histogram'],
+            observable_counter: h['observable_counter'],
+            observable_gauge: h['observable_gauge'],
+            observable_up_down_counter: h['observable_up_down_counter'],
+            up_down_counter: h['up_down_counter']
+          )
+        end
+      end
+
+      ConsoleMetricExporter = Struct.new(
+        :temporality_preference,
+        :default_histogram_aggregation,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            temporality_preference: h['temporality_preference'],
+            default_histogram_aggregation: h['default_histogram_aggregation']
+          )
+        end
+      end
+
+      ExperimentalComposableParentThresholdSampler = Struct.new(
+        :root,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            root: ExperimentalComposableSampler.from_hash(h['root'])
+          )
+        end
+      end
+
+      ExperimentalComposableProbabilitySampler = Struct.new(
+        :ratio,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            ratio: h['ratio']
+          )
+        end
+      end
+
+      ExperimentalComposableRuleBasedSampler = Struct.new(
+        :rules,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            rules: Array(h['rules']).filter_map { |e| ExperimentalComposableRuleBasedSamplerRule.from_hash(e) }
+          )
+        end
+      end
+
+      ExperimentalComposableRuleBasedSamplerRule = Struct.new(
+        :attribute_values,
+        :attribute_patterns,
+        :span_kinds,
+        :parent,
+        :sampler,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            attribute_values: ExperimentalComposableRuleBasedSamplerRuleAttributeValues.from_hash(h['attribute_values']),
+            attribute_patterns: ExperimentalComposableRuleBasedSamplerRuleAttributePatterns.from_hash(h['attribute_patterns']),
+            span_kinds: h['span_kinds'],
+            parent: h['parent'],
+            sampler: ExperimentalComposableSampler.from_hash(h['sampler'])
+          )
+        end
+      end
+
+      ExperimentalComposableRuleBasedSamplerRuleAttributePatterns = Struct.new(
+        :key,
+        :included,
+        :excluded,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            key: h['key'],
+            included: h['included'],
+            excluded: h['excluded']
+          )
+        end
+      end
+
+      ExperimentalComposableRuleBasedSamplerRuleAttributeValues = Struct.new(
+        :key,
+        :values,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            key: h['key'],
+            values: h['values']
+          )
+        end
+      end
+
+      ExperimentalComposableSampler = Struct.new(
+        :always_off,
+        :always_on,
+        :parent_threshold,
+        :probability,
+        :rule_based,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            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']),
+            additional_properties: h.except('always_off', 'always_on', 'parent_threshold', 'probability', 'rule_based')
+          )
+        end
+      end
+
+      ExperimentalGeneralInstrumentation = Struct.new(
+        :peer,
+        :http,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            peer: ExperimentalPeerInstrumentation.from_hash(h['peer']),
+            http: ExperimentalHttpInstrumentation.from_hash(h['http'])
+          )
+        end
+      end
+
+      ExperimentalHttpClientInstrumentation = Struct.new(
+        :request_captured_headers,
+        :response_captured_headers,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            request_captured_headers: h['request_captured_headers'],
+            response_captured_headers: h['response_captured_headers']
+          )
+        end
+      end
+
+      ExperimentalHttpInstrumentation = Struct.new(
+        :client,
+        :server,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            client: ExperimentalHttpClientInstrumentation.from_hash(h['client']),
+            server: ExperimentalHttpServerInstrumentation.from_hash(h['server'])
+          )
+        end
+      end
+
+      ExperimentalHttpServerInstrumentation = Struct.new(
+        :request_captured_headers,
+        :response_captured_headers,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            request_captured_headers: h['request_captured_headers'],
+            response_captured_headers: h['response_captured_headers']
+          )
+        end
+      end
+
+      ExperimentalInstrumentation = Struct.new(
+        :general,
+        :cpp,
+        :dotnet,
+        :erlang,
+        :go,
+        :java,
+        :js,
+        :php,
+        :python,
+        :ruby,
+        :rust,
+        :swift,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            general: ExperimentalGeneralInstrumentation.from_hash(h['general']),
+            cpp: h['cpp'],
+            dotnet: h['dotnet'],
+            erlang: h['erlang'],
+            go: h['go'],
+            java: h['java'],
+            js: h['js'],
+            php: h['php'],
+            python: h['python'],
+            ruby: h['ruby'],
+            rust: h['rust'],
+            swift: h['swift']
+          )
+        end
+      end
+
+      ExperimentalJaegerRemoteSampler = Struct.new(
+        :endpoint,
+        :interval,
+        :initial_sampler,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            endpoint: h['endpoint'],
+            interval: h['interval'],
+            initial_sampler: Sampler.from_hash(h['initial_sampler'])
+          )
+        end
+      end
+
+      ExperimentalLoggerConfig = Struct.new(
+        :disabled,
+        :minimum_severity,
+        :trace_based,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            disabled: h['disabled'],
+            minimum_severity: h['minimum_severity'],
+            trace_based: h['trace_based']
+          )
+        end
+      end
+
+      ExperimentalLoggerConfigurator = Struct.new(
+        :default_config,
+        :loggers,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            default_config: ExperimentalLoggerConfig.from_hash(h['default_config']),
+            loggers: Array(h['loggers']).filter_map { |e| ExperimentalLoggerMatcherAndConfig.from_hash(e) }
+          )
+        end
+      end
+
+      ExperimentalLoggerMatcherAndConfig = Struct.new(
+        :name,
+        :config,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            name: h['name'],
+            config: ExperimentalLoggerConfig.from_hash(h['config'])
+          )
+        end
+      end
+
+      ExperimentalMeterConfig = Struct.new(
+        :disabled,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            disabled: h['disabled']
+          )
+        end
+      end
+
+      ExperimentalMeterConfigurator = Struct.new(
+        :default_config,
+        :meters,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            default_config: ExperimentalMeterConfig.from_hash(h['default_config']),
+            meters: Array(h['meters']).filter_map { |e| ExperimentalMeterMatcherAndConfig.from_hash(e) }
+          )
+        end
+      end
+
+      ExperimentalMeterMatcherAndConfig = Struct.new(
+        :name,
+        :config,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            name: h['name'],
+            config: ExperimentalMeterConfig.from_hash(h['config'])
+          )
+        end
+      end
+
+      ExperimentalOtlpFileExporter = Struct.new(
+        :output_stream,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            output_stream: h['output_stream']
+          )
+        end
+      end
+
+      ExperimentalOtlpFileMetricExporter = Struct.new(
+        :output_stream,
+        :temporality_preference,
+        :default_histogram_aggregation,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            output_stream: h['output_stream'],
+            temporality_preference: h['temporality_preference'],
+            default_histogram_aggregation: h['default_histogram_aggregation']
+          )
+        end
+      end
+
+      ExperimentalPeerInstrumentation = Struct.new(
+        :service_mapping,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            service_mapping: Array(h['service_mapping']).filter_map { |e| ExperimentalPeerServiceMapping.from_hash(e) }
+          )
+        end
+      end
+
+      ExperimentalPeerServiceMapping = Struct.new(
+        :peer,
+        :service,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            peer: h['peer'],
+            service: h['service']
+          )
+        end
+      end
+
+      ExperimentalProbabilitySampler = Struct.new(
+        :ratio,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            ratio: h['ratio']
+          )
+        end
+      end
+
+      ExperimentalPrometheusMetricExporter = Struct.new(
+        :host,
+        :port,
+        :without_scope_info,
+        :without_target_info,
+        :with_resource_constant_labels,
+        :translation_strategy,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            host: h['host'],
+            port: h['port'],
+            without_scope_info: h['without_scope_info'],
+            without_target_info: h['without_target_info'],
+            with_resource_constant_labels: IncludeExclude.from_hash(h['with_resource_constant_labels']),
+            translation_strategy: h['translation_strategy']
+          )
+        end
+      end
+
+      ExperimentalResourceDetection = Struct.new(
+        :attributes,
+        :detectors,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            attributes: IncludeExclude.from_hash(h['attributes']),
+            detectors: Array(h['detectors']).filter_map { |e| ExperimentalResourceDetector.from_hash(e) }
+          )
+        end
+      end
+
+      ExperimentalResourceDetector = Struct.new(
+        :container,
+        :host,
+        :process,
+        :service,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            container: h.key?('container'),
+            host: h.key?('host'),
+            process: h.key?('process'),
+            service: h.key?('service'),
+            additional_properties: h.except('container', 'host', 'process', 'service')
+          )
+        end
+      end
+
+      ExperimentalTracerConfig = Struct.new(
+        :disabled,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            disabled: h['disabled']
+          )
+        end
+      end
+
+      ExperimentalTracerConfigurator = Struct.new(
+        :default_config,
+        :tracers,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            default_config: ExperimentalTracerConfig.from_hash(h['default_config']),
+            tracers: Array(h['tracers']).filter_map { |e| ExperimentalTracerMatcherAndConfig.from_hash(e) }
+          )
+        end
+      end
+
+      ExperimentalTracerMatcherAndConfig = Struct.new(
+        :name,
+        :config,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            name: h['name'],
+            config: ExperimentalTracerConfig.from_hash(h['config'])
+          )
+        end
+      end
+
+      ExplicitBucketHistogramAggregation = Struct.new(
+        :boundaries,
+        :record_min_max,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            boundaries: h['boundaries'],
+            record_min_max: h['record_min_max']
+          )
+        end
+      end
+
+      GrpcTls = Struct.new(
+        :ca_file,
+        :key_file,
+        :cert_file,
+        :insecure,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            ca_file: h['ca_file'],
+            key_file: h['key_file'],
+            cert_file: h['cert_file'],
+            insecure: h['insecure']
+          )
+        end
+      end
+
+      HttpTls = Struct.new(
+        :ca_file,
+        :key_file,
+        :cert_file,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            ca_file: h['ca_file'],
+            key_file: h['key_file'],
+            cert_file: h['cert_file']
+          )
+        end
+      end
+
+      IncludeExclude = Struct.new(
+        :included,
+        :excluded,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            included: h['included'],
+            excluded: h['excluded']
+          )
+        end
+      end
+
+      LogRecordExporter = Struct.new(
+        :otlp_http,
+        :otlp_grpc,
+        :otlp_file_development,
+        :console,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          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']),
+            console: h.key?('console'),
+            additional_properties: h.except('otlp_http', 'otlp_grpc', 'otlp_file/development', 'console')
+          )
+        end
+      end
+
+      LogRecordLimits = Struct.new(
+        :attribute_value_length_limit,
+        :attribute_count_limit,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            attribute_value_length_limit: h['attribute_value_length_limit'],
+            attribute_count_limit: h['attribute_count_limit']
+          )
+        end
+      end
+
+      LogRecordProcessor = Struct.new(
+        :batch,
+        :simple,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            batch: BatchLogRecordProcessor.from_hash(h['batch']),
+            simple: SimpleLogRecordProcessor.from_hash(h['simple']),
+            additional_properties: h.except('batch', 'simple')
+          )
+        end
+      end
+
+      LoggerProvider = Struct.new(
+        :processors,
+        :limits,
+        :logger_configurator_development,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            processors: Array(h['processors']).filter_map { |e| LogRecordProcessor.from_hash(e) },
+            limits: LogRecordLimits.from_hash(h['limits']),
+            logger_configurator_development: ExperimentalLoggerConfigurator.from_hash(h['logger_configurator/development'])
+          )
+        end
+      end
+
+      MeterProvider = Struct.new(
+        :readers,
+        :views,
+        :exemplar_filter,
+        :meter_configurator_development,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            readers: Array(h['readers']).filter_map { |e| MetricReader.from_hash(e) },
+            views: Array(h['views']).filter_map { |e| View.from_hash(e) },
+            exemplar_filter: h['exemplar_filter'],
+            meter_configurator_development: ExperimentalMeterConfigurator.from_hash(h['meter_configurator/development'])
+          )
+        end
+      end
+
+      MetricProducer = Struct.new(
+        :opencensus,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            opencensus: h.key?('opencensus'),
+            additional_properties: h.except('opencensus')
+          )
+        end
+      end
+
+      MetricReader = Struct.new(
+        :periodic,
+        :pull,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            periodic: PeriodicMetricReader.from_hash(h['periodic']),
+            pull: PullMetricReader.from_hash(h['pull'])
+          )
+        end
+      end
+
+      NameStringValuePair = Struct.new(
+        :name,
+        :value,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            name: h['name'],
+            value: h['value']
+          )
+        end
+      end
+
+      OpenTelemetryConfiguration = Struct.new(
+        :file_format,
+        :disabled,
+        :log_level,
+        :attribute_limits,
+        :logger_provider,
+        :meter_provider,
+        :propagator,
+        :tracer_provider,
+        :resource,
+        :instrumentation_development,
+        :distribution,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            file_format: h['file_format'],
+            disabled: h['disabled'],
+            log_level: h['log_level'],
+            attribute_limits: AttributeLimits.from_hash(h['attribute_limits']),
+            logger_provider: LoggerProvider.from_hash(h['logger_provider']),
+            meter_provider: MeterProvider.from_hash(h['meter_provider']),
+            propagator: Propagator.from_hash(h['propagator']),
+            tracer_provider: TracerProvider.from_hash(h['tracer_provider']),
+            resource: Resource.from_hash(h['resource']),
+            instrumentation_development: ExperimentalInstrumentation.from_hash(h['instrumentation/development']),
+            distribution: h['distribution'],
+            additional_properties: h.except('file_format', 'disabled', 'log_level', 'attribute_limits', 'logger_provider', 'meter_provider', 'propagator', 'tracer_provider', 'resource', 'instrumentation/development', 'distribution')
+          )
+        end
+      end
+
+      OtlpGrpcExporter = Struct.new(
+        :endpoint,
+        :tls,
+        :headers,
+        :headers_list,
+        :compression,
+        :timeout,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            endpoint: h['endpoint'],
+            tls: GrpcTls.from_hash(h['tls']),
+            headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
+            headers_list: h['headers_list'],
+            compression: h['compression'],
+            timeout: h['timeout']
+          )
+        end
+      end
+
+      OtlpGrpcMetricExporter = Struct.new(
+        :endpoint,
+        :tls,
+        :headers,
+        :headers_list,
+        :compression,
+        :timeout,
+        :temporality_preference,
+        :default_histogram_aggregation,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            endpoint: h['endpoint'],
+            tls: GrpcTls.from_hash(h['tls']),
+            headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
+            headers_list: h['headers_list'],
+            compression: h['compression'],
+            timeout: h['timeout'],
+            temporality_preference: h['temporality_preference'],
+            default_histogram_aggregation: h['default_histogram_aggregation']
+          )
+        end
+      end
+
+      OtlpHttpExporter = Struct.new(
+        :endpoint,
+        :tls,
+        :headers,
+        :headers_list,
+        :compression,
+        :timeout,
+        :encoding,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            endpoint: h['endpoint'],
+            tls: HttpTls.from_hash(h['tls']),
+            headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
+            headers_list: h['headers_list'],
+            compression: h['compression'],
+            timeout: h['timeout'],
+            encoding: h['encoding']
+          )
+        end
+      end
+
+      OtlpHttpMetricExporter = Struct.new(
+        :endpoint,
+        :tls,
+        :headers,
+        :headers_list,
+        :compression,
+        :timeout,
+        :encoding,
+        :temporality_preference,
+        :default_histogram_aggregation,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            endpoint: h['endpoint'],
+            tls: HttpTls.from_hash(h['tls']),
+            headers: Array(h['headers']).filter_map { |e| NameStringValuePair.from_hash(e) },
+            headers_list: h['headers_list'],
+            compression: h['compression'],
+            timeout: h['timeout'],
+            encoding: h['encoding'],
+            temporality_preference: h['temporality_preference'],
+            default_histogram_aggregation: h['default_histogram_aggregation']
+          )
+        end
+      end
+
+      ParentBasedSampler = Struct.new(
+        :root,
+        :remote_parent_sampled,
+        :remote_parent_not_sampled,
+        :local_parent_sampled,
+        :local_parent_not_sampled,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            root: Sampler.from_hash(h['root']),
+            remote_parent_sampled: Sampler.from_hash(h['remote_parent_sampled']),
+            remote_parent_not_sampled: Sampler.from_hash(h['remote_parent_not_sampled']),
+            local_parent_sampled: Sampler.from_hash(h['local_parent_sampled']),
+            local_parent_not_sampled: Sampler.from_hash(h['local_parent_not_sampled'])
+          )
+        end
+      end
+
+      PeriodicMetricReader = Struct.new(
+        :interval,
+        :timeout,
+        :exporter,
+        :producers,
+        :cardinality_limits,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            interval: h['interval'],
+            timeout: h['timeout'],
+            exporter: PushMetricExporter.from_hash(h['exporter']),
+            producers: Array(h['producers']).filter_map { |e| MetricProducer.from_hash(e) },
+            cardinality_limits: CardinalityLimits.from_hash(h['cardinality_limits'])
+          )
+        end
+      end
+
+      Propagator = Struct.new(
+        :composite,
+        :composite_list,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            composite: Array(h['composite']).filter_map { |e| TextMapPropagator.from_hash(e) },
+            composite_list: h['composite_list']
+          )
+        end
+      end
+
+      PullMetricExporter = Struct.new(
+        :prometheus_development,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            prometheus_development: ExperimentalPrometheusMetricExporter.from_hash(h['prometheus/development']),
+            additional_properties: h.except('prometheus/development')
+          )
+        end
+      end
+
+      PullMetricReader = Struct.new(
+        :exporter,
+        :producers,
+        :cardinality_limits,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            exporter: PullMetricExporter.from_hash(h['exporter']),
+            producers: Array(h['producers']).filter_map { |e| MetricProducer.from_hash(e) },
+            cardinality_limits: CardinalityLimits.from_hash(h['cardinality_limits'])
+          )
+        end
+      end
+
+      PushMetricExporter = Struct.new(
+        :otlp_http,
+        :otlp_grpc,
+        :otlp_file_development,
+        :console,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          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']),
+            additional_properties: h.except('otlp_http', 'otlp_grpc', 'otlp_file/development', 'console')
+          )
+        end
+      end
+
+      Resource = Struct.new(
+        :attributes,
+        :detection_development,
+        :schema_url,
+        :attributes_list,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            attributes: Array(h['attributes']).filter_map { |e| AttributeNameValue.from_hash(e) },
+            detection_development: ExperimentalResourceDetection.from_hash(h['detection/development']),
+            schema_url: h['schema_url'],
+            attributes_list: h['attributes_list']
+          )
+        end
+      end
+
+      Sampler = Struct.new(
+        :always_off,
+        :always_on,
+        :composite_development,
+        :jaeger_remote_development,
+        :parent_based,
+        :probability_development,
+        :trace_id_ratio_based,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            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']),
+            additional_properties: h.except('always_off', 'always_on', 'composite/development', 'jaeger_remote/development', 'parent_based', 'probability/development', 'trace_id_ratio_based')
+          )
+        end
+      end
+
+      SimpleLogRecordProcessor = Struct.new(
+        :exporter,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            exporter: LogRecordExporter.from_hash(h['exporter'])
+          )
+        end
+      end
+
+      SimpleSpanProcessor = Struct.new(
+        :exporter,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            exporter: SpanExporter.from_hash(h['exporter'])
+          )
+        end
+      end
+
+      SpanExporter = Struct.new(
+        :otlp_http,
+        :otlp_grpc,
+        :otlp_file_development,
+        :console,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          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']),
+            console: h.key?('console'),
+            additional_properties: h.except('otlp_http', 'otlp_grpc', 'otlp_file/development', 'console')
+          )
+        end
+      end
+
+      SpanLimits = Struct.new(
+        :attribute_value_length_limit,
+        :attribute_count_limit,
+        :event_count_limit,
+        :link_count_limit,
+        :event_attribute_count_limit,
+        :link_attribute_count_limit,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            attribute_value_length_limit: h['attribute_value_length_limit'],
+            attribute_count_limit: h['attribute_count_limit'],
+            event_count_limit: h['event_count_limit'],
+            link_count_limit: h['link_count_limit'],
+            event_attribute_count_limit: h['event_attribute_count_limit'],
+            link_attribute_count_limit: h['link_attribute_count_limit']
+          )
+        end
+      end
+
+      SpanProcessor = Struct.new(
+        :batch,
+        :simple,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            batch: BatchSpanProcessor.from_hash(h['batch']),
+            simple: SimpleSpanProcessor.from_hash(h['simple']),
+            additional_properties: h.except('batch', 'simple')
+          )
+        end
+      end
+
+      TextMapPropagator = Struct.new(
+        :tracecontext,
+        :baggage,
+        :b3,
+        :b3multi,
+        :jaeger,
+        :ottrace,
+        :additional_properties,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            tracecontext: h.key?('tracecontext'),
+            baggage: h.key?('baggage'),
+            b3: h.key?('b3'),
+            b3multi: h.key?('b3multi'),
+            jaeger: h.key?('jaeger'),
+            ottrace: h.key?('ottrace'),
+            additional_properties: h.except('tracecontext', 'baggage', 'b3', 'b3multi', 'jaeger', 'ottrace')
+          )
+        end
+      end
+
+      TraceIdRatioBasedSampler = Struct.new(
+        :ratio,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            ratio: h['ratio']
+          )
+        end
+      end
+
+      TracerProvider = Struct.new(
+        :processors,
+        :limits,
+        :sampler,
+        :tracer_configurator_development,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            processors: Array(h['processors']).filter_map { |e| SpanProcessor.from_hash(e) },
+            limits: SpanLimits.from_hash(h['limits']),
+            sampler: Sampler.from_hash(h['sampler']),
+            tracer_configurator_development: ExperimentalTracerConfigurator.from_hash(h['tracer_configurator/development'])
+          )
+        end
+      end
+
+      View = Struct.new(
+        :selector,
+        :stream,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            selector: ViewSelector.from_hash(h['selector']),
+            stream: ViewStream.from_hash(h['stream'])
+          )
+        end
+      end
+
+      ViewSelector = Struct.new(
+        :instrument_name,
+        :instrument_type,
+        :unit,
+        :meter_name,
+        :meter_version,
+        :meter_schema_url,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            instrument_name: h['instrument_name'],
+            instrument_type: h['instrument_type'],
+            unit: h['unit'],
+            meter_name: h['meter_name'],
+            meter_version: h['meter_version'],
+            meter_schema_url: h['meter_schema_url']
+          )
+        end
+      end
+
+      ViewStream = Struct.new(
+        :name,
+        :description,
+        :aggregation,
+        :aggregation_cardinality_limit,
+        :attribute_keys,
+        keyword_init: true
+      ) do
+        def self.from_hash(h)
+          return nil unless h.is_a?(Hash)
+
+          new(
+            name: h['name'],
+            description: h['description'],
+            aggregation: Aggregation.from_hash(h['aggregation']),
+            aggregation_cardinality_limit: h['aggregation_cardinality_limit'],
+            attribute_keys: IncludeExclude.from_hash(h['attribute_keys'])
+          )
+        end
+      end
+    end
+  end
+end