feat(opentelemetry-configuration): parse logger provider from config file

experimental/CHANGELOG.md

@@ -59,6 +59,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2
 * feat(opentelemetry-configuration): parse more parameters from config file [#5955](https://github.com/open-telemetry/opentelemetry-js/pull/5955) @maryliag
 * feat(exporter-prometheus): support withoutTargetInfo option [#5962](https://github.com/open-telemetry/opentelemetry-js/pull/5962) @cjihrig
 * feat(opentelemetry-configuration): parse trace provider from config file [#5992](https://github.com/open-telemetry/opentelemetry-js/pull/5992) @maryliag
+* feat(opentelemetry-configuration): parse logger provider from config file [#5995](https://github.com/open-telemetry/opentelemetry-js/pull/5995) @maryliag
 * feat(opentelemetry-configuration): parse config file with format 1.0-rc.2 [#6029](https://github.com/open-telemetry/opentelemetry-js/pull/6029) @maryliag
 
 ### :bug: Bug Fixes

experimental/packages/opentelemetry-configuration/src/EnvironmentConfigProvider.ts

@@ -62,7 +62,7 @@ export class EnvironmentConfigProvider implements ConfigProvider {
   }
 }
 
-function setResources(config: ConfigurationModel): void {
+export function setResources(config: ConfigurationModel): void {
   if (config.resource == null) {
     config.resource = {};
   }
@@ -84,7 +84,7 @@ function setResources(config: ConfigurationModel): void {
   }
 }
 
-function setAttributeLimits(config: ConfigurationModel): void {
+export function setAttributeLimits(config: ConfigurationModel): void {
   const attributeValueLengthLimit = getNumberFromEnv(
     'OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT'
   );
@@ -106,7 +106,7 @@ function setAttributeLimits(config: ConfigurationModel): void {
   }
 }
 
-function setPropagators(config: ConfigurationModel): void {
+export function setPropagators(config: ConfigurationModel): void {
   if (config.propagator == null) {
     config.propagator = {};
   }
@@ -123,7 +123,7 @@ function setPropagators(config: ConfigurationModel): void {
   }
 }
 
-function setTracerProvider(config: ConfigurationModel): void {
+export function setTracerProvider(config: ConfigurationModel): void {
   if (config.tracer_provider == null) {
     config.tracer_provider = { processors: [] };
   }
@@ -349,17 +349,17 @@ function setMeterProvider(config: ConfigurationModel): void {
   }
 }
 
-function setLoggerProvider(config: ConfigurationModel): void {
+export function setLoggerProvider(config: ConfigurationModel): void {
+  if (config.logger_provider == null) {
+    config.logger_provider = { processors: [] };
+  }
   const attributeValueLengthLimit = getNumberFromEnv(
     'OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT'
   );
   const attributeCountLimit = getNumberFromEnv(
     'OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT'
   );
   if (attributeValueLengthLimit || attributeCountLimit) {
-    if (config.logger_provider == null) {
-      config.logger_provider = {};
-    }
     if (config.logger_provider.limits == null) {
       config.logger_provider.limits = { attribute_count_limit: 128 };
     }
@@ -442,12 +442,6 @@ function setLoggerProvider(config: ConfigurationModel): void {
       batch.exporter.otlp_http.headers_list = headersList;
     }
 
-    if (config.logger_provider == null) {
-      config.logger_provider = { processors: [{}] };
-    }
-    if (config.logger_provider?.processors == null) {
-      config.logger_provider.processors = [{}];
-    }
     config.logger_provider.processors[0].batch = batch;
   }
 }

experimental/packages/opentelemetry-configuration/src/FileConfigProvider.ts

@@ -17,8 +17,6 @@
 import { diagLogLevelFromString, getStringFromEnv } from '@opentelemetry/core';
 import {
   AttributeLimits,
-  ConfigAttributes,
-  LoggerProvider,
   MeterProvider,
   Propagator,
   ConfigurationModel,
@@ -41,6 +39,12 @@ import {
   SpanProcessor,
   TracerProvider,
 } from './models/tracerProviderModel';
+import {
+  LoggerProvider,
+  LogRecordExporter,
+  LogRecordProcessor,
+} from './models/loggerProviderModel';
+import { AttributeNameValue } from './models/resourceModel';
 
 export class FileConfigProvider implements ConfigProvider {
   private _config: ConfigurationModel;
@@ -71,7 +75,7 @@ export function hasValidConfigFile(): boolean {
   return false;
 }
 
-function parseConfigFile(config: ConfigurationModel) {
+export function parseConfigFile(config: ConfigurationModel) {
   const supportedFileVersions = ['1.0-rc.1', '1.0-rc.2'];
   const configFile = getStringFromEnv('OTEL_EXPERIMENTAL_CONFIG_FILE') || '';
   const file = fs.readFileSync(configFile, 'utf8');
@@ -125,9 +129,9 @@ function parseConfigFile(config: ConfigurationModel) {
   }
 }
 
-function setResourceAttributes(
+export function setResourceAttributes(
   config: ConfigurationModel,
-  attributes: ConfigAttributes[]
+  attributes: AttributeNameValue[]
 ) {
   if (attributes) {
     if (config.resource == null) {
@@ -169,7 +173,7 @@ function setResourceAttributes(
   }
 }
 
-function setAttributeLimits(
+export function setAttributeLimits(
   config: ConfigurationModel,
   attrLimits: AttributeLimits
 ) {
@@ -194,7 +198,7 @@ function setAttributeLimits(
   }
 }
 
-function setPropagator(
+export function setPropagator(
   config: ConfigurationModel,
   propagator: Propagator
 ): void {
@@ -254,9 +258,18 @@ function getConfigHeaders(
   return null;
 }
 
-function parseConfigExporter(exporter: SpanExporter): SpanExporter {
+enum ProviderType {
+  TRACER = 0,
+  METER = 1,
+  LOGGER = 2,
+}
+
+function parseConfigExporter(
+  exporter: SpanExporter | LogRecordExporter,
+  providerType: ProviderType
+): SpanExporter | LogRecordExporter {
   const exporterType = Object.keys(exporter)[0];
-  let parsedExporter: SpanExporter = {};
+  let parsedExporter: SpanExporter | LogRecordExporter = {};
   let e;
   let certFile;
   let clientCertFile;
@@ -265,15 +278,26 @@ function parseConfigExporter(exporter: SpanExporter): SpanExporter {
   let headers;
   let headersList;
   let insecure;
+  let endpoint;
+
+  switch (providerType) {
+    case ProviderType.TRACER:
+      endpoint = 'http://localhost:4318/v1/traces';
+      parsedExporter = parsedExporter as SpanExporter;
+      break;
+    case ProviderType.LOGGER:
+      endpoint = 'http://localhost:4318/v1/logs';
+      parsedExporter = parsedExporter as LogRecordExporter;
+      break;
+  }
+
   switch (exporterType) {
     case 'otlp_http':
       e = exporter['otlp_http'];
       if (e) {
         parsedExporter = {
           otlp_http: {
-            endpoint:
-              getStringFromConfigFile(e['endpoint']) ??
-              'http://localhost:4318/v1/traces',
+            endpoint: getStringFromConfigFile(e['endpoint']) ?? endpoint,
             timeout: getNumberFromConfigFile(e['timeout']) ?? 10000,
             encoding:
               getStringFromConfigFile(e['encoding']) === 'json'
@@ -370,7 +394,7 @@ function parseConfigExporter(exporter: SpanExporter): SpanExporter {
       break;
 
     case 'zipkin':
-      e = exporter['zipkin'];
+      e = (exporter as SpanExporter)['zipkin'];
       if (e) {
         parsedExporter = {
           zipkin: {
@@ -387,7 +411,7 @@ function parseConfigExporter(exporter: SpanExporter): SpanExporter {
   return parsedExporter;
 }
 
-function setTracerProvider(
+export function setTracerProvider(
   config: ConfigurationModel,
   tracerProvider: TracerProvider
 ): void {
@@ -460,7 +484,10 @@ function setTracerProvider(
         if (processorType === 'batch') {
           const element = tracerProvider['processors'][i]['batch'];
           if (element) {
-            const parsedExporter = parseConfigExporter(element['exporter']);
+            const parsedExporter = parseConfigExporter(
+              element['exporter'],
+              ProviderType.TRACER
+            );
             const batchConfig: SpanProcessor = {
               batch: {
                 schedule_delay:
@@ -472,7 +499,7 @@ function setTracerProvider(
                 max_export_batch_size:
                   getNumberFromConfigFile(element['max_export_batch_size']) ??
                   512,
-                exporter: parsedExporter,
+                exporter: parsedExporter as SpanExporter,
               },
             };
 
@@ -481,10 +508,13 @@ function setTracerProvider(
         } else if (processorType === 'simple') {
           const element = tracerProvider['processors'][i]['simple'];
           if (element) {
-            const parsedExporter = parseConfigExporter(element['exporter']);
+            const parsedExporter = parseConfigExporter(
+              element['exporter'],
+              ProviderType.TRACER
+            );
             const simpleConfig: SpanProcessor = {
               simple: {
-                exporter: parsedExporter,
+                exporter: parsedExporter as SpanExporter,
               },
             };
 
@@ -496,7 +526,7 @@ function setTracerProvider(
   }
 }
 
-function setMeterProvider(
+export function setMeterProvider(
   config: ConfigurationModel,
   meterProvider: MeterProvider
 ): void {
@@ -518,14 +548,15 @@ function setMeterProvider(
   }
 }
 
-function setLoggerProvider(
+export function setLoggerProvider(
   config: ConfigurationModel,
   loggerProvider: LoggerProvider
 ): void {
   if (loggerProvider) {
     if (config.logger_provider == null) {
-      config.logger_provider = {};
+      config.logger_provider = { processors: [] };
     }
+    // Limits
     if (loggerProvider['limits']) {
       const attributeValueLengthLimit = getNumberFromConfigFile(
         loggerProvider['limits']['attribute_value_length_limit']
@@ -537,17 +568,124 @@ function setLoggerProvider(
         if (config.logger_provider.limits == null) {
           config.logger_provider.limits = { attribute_count_limit: 128 };
         }
-
         if (attributeValueLengthLimit) {
           config.logger_provider.limits.attribute_value_length_limit =
             attributeValueLengthLimit;
         }
-
         if (attributeCountLimit) {
           config.logger_provider.limits.attribute_count_limit =
             attributeCountLimit;
         }
       }
     }
+
+    // Processors
+    if (loggerProvider['processors']) {
+      if (loggerProvider['processors'].length > 0) {
+        if (config.logger_provider == null) {
+          config.logger_provider = { processors: [] };
+        }
+        config.logger_provider.processors = [];
+        for (let i = 0; i < loggerProvider['processors'].length; i++) {
+          const processorType = Object.keys(loggerProvider['processors'][i])[0];
+          if (processorType === 'batch') {
+            const element = loggerProvider['processors'][i]['batch'];
+            if (element) {
+              const parsedExporter = parseConfigExporter(
+                element['exporter'],
+                ProviderType.LOGGER
+              );
+              const batchConfig: LogRecordProcessor = {
+                batch: {
+                  schedule_delay:
+                    getNumberFromConfigFile(element['schedule_delay']) ?? 1000,
+                  export_timeout:
+                    getNumberFromConfigFile(element['export_timeout']) ?? 30000,
+                  max_queue_size:
+                    getNumberFromConfigFile(element['max_queue_size']) ?? 2048,
+                  max_export_batch_size:
+                    getNumberFromConfigFile(element['max_export_batch_size']) ??
+                    512,
+                  exporter: parsedExporter as LogRecordExporter,
+                },
+              };
+
+              config.logger_provider.processors.push(batchConfig);
+            }
+          } else if (processorType === 'simple') {
+            const element = loggerProvider['processors'][i]['simple'];
+            if (element) {
+              const parsedExporter = parseConfigExporter(
+                element['exporter'],
+                ProviderType.LOGGER
+              );
+              const simpleConfig: LogRecordProcessor = {
+                simple: {
+                  exporter: parsedExporter,
+                },
+              };
+
+              config.logger_provider.processors.push(simpleConfig);
+            }
+          }
+        }
+      }
+    }
+
+    // logger_configurator/development
+    if (loggerProvider['logger_configurator/development']) {
+      const defaultConfigDisabled = getBooleanFromConfigFile(
+        loggerProvider['logger_configurator/development']['default_config']?.[
+          'disabled'
+        ]
+      );
+      if (defaultConfigDisabled || defaultConfigDisabled === false) {
+        if (config.logger_provider == null) {
+          config.logger_provider = { processors: [] };
+        }
+        config.logger_provider['logger_configurator/development'] = {
+          default_config: {
+            disabled: defaultConfigDisabled,
+          },
+        };
+      }
+
+      if (
+        loggerProvider['logger_configurator/development'].loggers &&
+        loggerProvider['logger_configurator/development'].loggers.length > 0
+      ) {
+        const loggers = [];
+        for (
+          let i = 0;
+          i < loggerProvider['logger_configurator/development'].loggers.length;
+          i++
+        ) {
+          const logger =
+            loggerProvider['logger_configurator/development'].loggers[i];
+          let disabled = false;
+          if (logger['config']) {
+            disabled =
+              getBooleanFromConfigFile(logger['config']['disabled']) ?? false;
+          }
+          const name = getStringFromConfigFile(logger['name']);
+          if (name) {
+            loggers.push({
+              name: name,
+              config: {
+                disabled: disabled,
+              },
+            });
+          }
+        }
+        if (config.logger_provider == null) {
+          config.logger_provider = { processors: [] };
+        }
+        if (config.logger_provider['logger_configurator/development'] == null) {
+          config.logger_provider['logger_configurator/development'] = {};
+        }
+        config.logger_provider['logger_configurator/development'].loggers =
+          loggers;
+      }
+    }
   }
 }