@twin.org/node-core 0.9.2-next.15 → 0.9.2-next.16

package/dist/es/builders/engineEnvBuilder.js

@@ -8,7 +8,7 @@ import { OpenTelemetryReaderTypes } from "@twin.org/telemetry-connector-opentele
 import { OpenTelemetryProcessorTypes } from "@twin.org/tracing-connector-opentelemetry";
 import { CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT } from "../defaults.js";
 import { isAuthEntityStorageRequired } from "./engineServerEnvBuilder.js";
-import { commaSeparatedListToArray, envBoolean, envCount, envDateTime, envInteger, envMinToMs, envMinutes, envMs, envSecToMs, envSeconds } from "./helper/envHelpers.js";
+import { commaSeparatedListToArray, envArray, envBoolean, envCount, envDateTime, envInteger, envMinToMs, envMinutes, envMs, envSecToMs, envSeconds } from "./helper/envHelpers.js";
 /**
  * Build the engine core configuration from environment variables.
  * @param envVars The environment variables.
@@ -525,45 +525,71 @@ async function configureEventBus(coreConfig, envVars) {
  */
 async function configureTelemetry(coreConfig, envVars) {
     coreConfig.types.telemetryConnector ??= [];
-    if (envVars.telemetryConnector === TelemetryConnectorType.EntityStorage) {
-        coreConfig.types.telemetryConnector.push({
-            type: TelemetryConnectorType.EntityStorage,
-            options: {
-                config: {
-                    batchSize: envCount(envVars, "telemetryBatchSize"),
-                    batchIntervalMs: envSecToMs(envVars, "telemetryBatchFlushInterval"),
-                    maxCacheSize: envCount(envVars, "telemetryMaxCacheSize"),
-                    mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout")
+    const telemetryConnectorTypes = commaSeparatedListToArray(envVars.telemetryConnector);
+    let additionalConnectorCount = 0;
+    for (const telemetryConnector of telemetryConnectorTypes) {
+        if (telemetryConnector === TelemetryConnectorType.Silent) {
+            coreConfig.types.telemetryConnector.push({
+                type: TelemetryConnectorType.Silent
+            });
+            additionalConnectorCount++;
+        }
+        else if (telemetryConnector === TelemetryConnectorType.EntityStorage) {
+            coreConfig.types.telemetryConnector.push({
+                type: TelemetryConnectorType.EntityStorage,
+                options: {
+                    config: {
+                        batchSize: envCount(envVars, "telemetryBatchSize"),
+                        batchIntervalMs: envSecToMs(envVars, "telemetryBatchFlushInterval"),
+                        maxCacheSize: envCount(envVars, "telemetryMaxCacheSize"),
+                        mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout"),
+                        metricDefinitionCacheCapacity: envCount(envVars, "telemetryMetricDefinitionCacheCapacity"),
+                        metricDefinitionCacheTtiMs: envMs(envVars, "telemetryMetricDefinitionCacheTtiMs")
+                    }
                 }
+            });
+            additionalConnectorCount++;
+        }
+        else if (telemetryConnector === TelemetryConnectorType.OpenTelemetry) {
+            let readers;
+            if (envVars.openTelemetryReader === OpenTelemetryReaderTypes.Prometheus) {
+                readers = {
+                    prometheus: {
+                        type: OpenTelemetryReaderTypes.Prometheus,
+                        port: envCount(envVars, "openTelemetryPrometheusPort")
+                    }
+                };
             }
-        });
-    }
-    else if (envVars.telemetryConnector === TelemetryConnectorType.OpenTelemetry) {
-        let readers;
-        if (envVars.openTelemetryReader === OpenTelemetryReaderTypes.Prometheus) {
-            readers = {
-                prometheus: {
-                    type: OpenTelemetryReaderTypes.Prometheus,
-                    port: envCount(envVars, "openTelemetryPrometheusPort")
+            coreConfig.types.telemetryConnector.push({
+                type: TelemetryConnectorType.OpenTelemetry,
+                options: {
+                    config: {
+                        meterName: envVars.openTelemetryMeterName,
+                        meterVersion: envVars.openTelemetryMeterVersion,
+                        readers
+                    }
                 }
-            };
+            });
+            additionalConnectorCount++;
         }
+    }
+    // If more than one telemetry connector, then we need to add a multi connector
+    // and set it as the default one
+    if (additionalConnectorCount > 1) {
         coreConfig.types.telemetryConnector.push({
-            type: TelemetryConnectorType.OpenTelemetry,
+            type: TelemetryConnectorType.Multi,
             options: {
-                config: {
-                    batchSize: envCount(envVars, "telemetryBatchSize"),
-                    batchIntervalMs: envSecToMs(envVars, "telemetryBatchFlushInterval"),
-                    maxCacheSize: envCount(envVars, "telemetryMaxCacheSize"),
-                    mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout"),
-                    meterName: envVars.openTelemetryMeterName,
-                    meterVersion: envVars.openTelemetryMeterVersion,
-                    readers
-                }
-            }
+                telemetryConnectorTypes
+            },
+            isDefault: true
         });
     }
-    if (coreConfig.types.telemetryConnector.length > 0) {
+    else if (additionalConnectorCount > 0) {
+        // If only one connector, then we set it as the default one
+        coreConfig.types.telemetryConnector[coreConfig.types.telemetryConnector.length - 1].isDefault =
+            true;
+    }
+    if (additionalConnectorCount > 0) {
         coreConfig.types.telemetryComponent ??= [];
         coreConfig.types.telemetryComponent.push({ type: TelemetryComponentType.Service });
     }
@@ -575,7 +601,7 @@ async function configureTelemetry(coreConfig, envVars) {
  * @returns A promise that resolves when the metrics collector configuration has been applied.
  */
 async function configureMetricsCollector(coreConfig, envVars) {
-    if (isTelemetryRequired(envVars)) {
+    if (isTelemetryEnabled(envVars)) {
         coreConfig.types.metricsCollectorComponent ??= [];
         coreConfig.types.metricsCollectorComponent.push({
             type: MetricsCollectorComponentType.Service,
@@ -606,38 +632,66 @@ async function configureMetricsCollector(coreConfig, envVars) {
  */
 async function configureTracing(coreConfig, envVars) {
     coreConfig.types.tracingConnector ??= [];
-    if (envVars.tracingConnector === TracingConnectorType.EntityStorage) {
-        coreConfig.types.tracingConnector.push({
-            type: TracingConnectorType.EntityStorage,
-            options: {
-                config: {
-                    mutexTimeoutMs: envMs(envVars, "tracingMutexTimeout")
+    const tracingConnectorTypes = commaSeparatedListToArray(envVars.tracingConnector);
+    let additionalConnectorCount = 0;
+    for (const tracingConnector of tracingConnectorTypes) {
+        if (tracingConnector === TracingConnectorType.Silent) {
+            coreConfig.types.tracingConnector.push({
+                type: TracingConnectorType.Silent
+            });
+            additionalConnectorCount++;
+        }
+        else if (tracingConnector === TracingConnectorType.EntityStorage) {
+            coreConfig.types.tracingConnector.push({
+                type: TracingConnectorType.EntityStorage,
+                options: {
+                    config: {
+                        mutexTimeoutMs: envMs(envVars, "tracingMutexTimeout")
+                    }
                 }
+            });
+            additionalConnectorCount++;
+        }
+        else if (tracingConnector === TracingConnectorType.OpenTelemetry) {
+            const otelTracingConfig = {
+                tracerName: envVars.openTelemetryTracingTracerName,
+                tracerVersion: envVars.openTelemetryTracingTracerVersion
+            };
+            if (Is.stringValue(envVars.openTelemetryTracingEndpoint)) {
+                otelTracingConfig.exporters = {
+                    otlp: {
+                        endpoint: envVars.openTelemetryTracingEndpoint,
+                        processor: envVars.openTelemetryTracingProcessor ??
+                            OpenTelemetryProcessorTypes.Batch
+                    }
+                };
             }
-        });
-    }
-    else if (envVars.tracingConnector === TracingConnectorType.OpenTelemetry) {
-        const otelTracingConfig = {
-            tracerName: envVars.openTelemetryTracingTracerName,
-            tracerVersion: envVars.openTelemetryTracingTracerVersion
-        };
-        if (Is.stringValue(envVars.openTelemetryTracingEndpoint)) {
-            otelTracingConfig.exporters = {
-                otlp: {
-                    endpoint: envVars.openTelemetryTracingEndpoint,
-                    processor: envVars.openTelemetryTracingProcessor ??
-                        OpenTelemetryProcessorTypes.Batch
+            coreConfig.types.tracingConnector.push({
+                type: TracingConnectorType.OpenTelemetry,
+                options: {
+                    config: otelTracingConfig
                 }
-            };
+            });
+            additionalConnectorCount++;
         }
+    }
+    // If more than one tracing connector, then we need to add a multi connector
+    // and set it as the default one
+    if (additionalConnectorCount > 1) {
         coreConfig.types.tracingConnector.push({
-            type: TracingConnectorType.OpenTelemetry,
+            type: TracingConnectorType.Multi,
             options: {
-                config: otelTracingConfig
-            }
+                tracingConnectorTypes
+            },
+            isDefault: true
         });
     }
-    if (coreConfig.types.tracingConnector.length > 0) {
+    else if (additionalConnectorCount > 0) {
+        // If only one connector, then we set it as the default one
+        coreConfig.types.tracingConnector[coreConfig.types.tracingConnector.length - 1].isDefault =
+            true;
+    }
+    if (additionalConnectorCount > 0) {
         coreConfig.types.tracingComponent ??= [];
         coreConfig.types.tracingComponent.push({ type: TracingComponentType.Service });
     }
@@ -811,16 +865,6 @@ async function configureMessaging(coreConfig, envVars) {
             });
         }
         else if (envVars.messagingPushNotificationConnector === MessagingPushNotificationConnectorType.Aws) {
-            let messagingApps;
-            if (Is.stringValue(envVars.awsMessagingPushNotificationApplications)) {
-                try {
-                    messagingApps = JSON.parse(envVars.awsMessagingPushNotificationApplications);
-                }
-                catch { }
-            }
-            else if (Is.array(envVars.awsMessagingPushNotificationApplications)) {
-                messagingApps = envVars.awsMessagingPushNotificationApplications;
-            }
             coreConfig.types.messagingPushNotificationConnector.push({
                 type: MessagingPushNotificationConnectorType.Aws,
                 options: {
@@ -830,7 +874,7 @@ async function configureMessaging(coreConfig, envVars) {
                         accessKeyId: envVars.awsSesAccessKeyId,
                         secretAccessKey: envVars.awsSesSecretAccessKey,
                         endpoint: envVars.awsSesEndpoint,
-                        applicationsSettings: messagingApps ?? []
+                        applicationsSettings: envArray(envVars, "awsMessagingPushNotificationApplications", [])
                     }
                 }
             });
@@ -1583,23 +1627,21 @@ export function isAutomationRequired(envVars) {
     return isRightsManagementRequired(envVars);
 }
 /**
- * Checks if the telemetry subsystem is required.
+ * Checks if the telemetry subsystem is enabled.
  * Returns true when any component that depends on the telemetry subsystem is enabled.
  * @param envVars The environment variables.
  * @returns True if telemetry is enabled.
  */
-export function isTelemetryRequired(envVars) {
-    return (envVars.telemetryConnector === TelemetryConnectorType.EntityStorage ||
-        envVars.telemetryConnector === TelemetryConnectorType.OpenTelemetry);
+export function isTelemetryEnabled(envVars) {
+    return commaSeparatedListToArray(envVars.telemetryConnector).some(t => t === TelemetryConnectorType.EntityStorage || t === TelemetryConnectorType.OpenTelemetry);
 }
 /**
- * Checks if the tracing subsystem is required.
+ * Checks if the tracing subsystem is enabled.
  * Returns true when any component that depends on the tracing subsystem is enabled.
  * @param envVars The environment variables.
  * @returns True if tracing is enabled.
  */
-export function isTracingRequired(envVars) {
-    return (envVars.tracingConnector === TracingConnectorType.EntityStorage ||
-        envVars.tracingConnector === TracingConnectorType.OpenTelemetry);
+export function isTracingEnabled(envVars) {
+    return commaSeparatedListToArray(envVars.tracingConnector).some(t => t === TracingConnectorType.EntityStorage || t === TracingConnectorType.OpenTelemetry);
 }
 //# sourceMappingURL=engineEnvBuilder.js.map