@azure/monitor-opentelemetry-exporter 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/index.js

@@ -66,7 +66,7 @@ const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
  * AzureMonitorTraceExporter version.
  * @internal
  */
-const packageVersion = "1.0.0-beta.11";
+const packageVersion = "1.0.0-beta.13";
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["InProc"] = "InProc";
@@ -76,35 +76,17 @@ var DependencyTypes;
     DependencyTypes["Grpc"] = "GRPC";
 })(DependencyTypes || (DependencyTypes = {}));
 const AzureMonitorSampleRate = "_MS.sampleRate";
-var StandardMetrics;
-(function (StandardMetrics) {
-    StandardMetrics["HTTP_REQUEST_DURATION"] = "azureMonitor.http.requestDuration";
-    StandardMetrics["HTTP_DEPENDENCY_DURATION"] = "azureMonitor.http.dependencyDuration";
-    StandardMetrics["EXCEPTION_COUNT"] = "azureMonitor.exceptionCount";
-    StandardMetrics["TRACE_COUNT"] = "azureMonitor.traceCount";
-})(StandardMetrics || (StandardMetrics = {}));
-var StandardMetricIds;
-(function (StandardMetricIds) {
-    StandardMetricIds["REQUEST_DURATION"] = "requests/duration";
-    StandardMetricIds["DEPENDENCY_DURATION"] = "dependencies/duration";
-    StandardMetricIds["EXCEPTION_COUNT"] = "exceptions/count";
-    StandardMetricIds["TRACE_COUNT"] = "traces/count";
-})(StandardMetricIds || (StandardMetricIds = {}));
-// Names expected in Breeze side for dimensions
-const PreAggregatedMetricPropertyNames = {
-    cloudRoleInstance: "cloud/roleInstance",
-    cloudRoleName: "cloud/roleName",
-    operationSynthetic: "operation/synthetic",
-    requestSuccess: "Request.Success",
-    requestResultCode: "request/resultCode",
-    dependencyType: "Dependency.Type",
-    dependencyTarget: "dependency/target",
-    dependencySuccess: "Dependency.Success",
-    dependencyResultCode: "dependency/resultCode",
-    traceSeverityLevel: "trace/severityLevel",
-    metricId: "_MS.MetricId",
-    IsAutocollected: "_MS.IsAutocollected",
-};
+const ApplicationInsightsBaseType = "_MS.baseType";
+const ApplicationInsightsMessageName = "Microsoft.ApplicationInsights.Message";
+const ApplicationInsightsExceptionName = "Microsoft.ApplicationInsights.Exception";
+const ApplicationInsightsPageViewName = "Microsoft.ApplicationInsights.PageView";
+const ApplicationInsightsAvailabilityName = "Microsoft.ApplicationInsights.Availability";
+const ApplicationInsightsEventName = "Microsoft.ApplicationInsights.Event";
+const ApplicationInsightsMessageBaseType = "MessageData";
+const ApplicationInsightsExceptionBaseType = "TelemetryExceptionData";
+const ApplicationInsightsPageViewBaseType = "PageViewData";
+const ApplicationInsightsAvailabilityBaseType = "AvailabilityData";
+const ApplicationInsightsEventBaseType = "TelemetryEventData";
 
 /**
  * ApplicationInsightsSampler is responsible for the following:
@@ -217,6 +199,11 @@ const DEFAULT_LIVEMETRICS_ENDPOINT = "https://rt.services.visualstudio.com";
  * @internal
  */
 const ENV_CONNECTION_STRING = "APPLICATIONINSIGHTS_CONNECTION_STRING";
+/**
+ * Disable Statsbeat environment variable name.
+ * @internal
+ */
+const ENV_DISABLE_STATSBEAT = "APPLICATION_INSIGHTS_NO_STATSBEAT";
 /**
  * QuickPulse metric counter names.
  * @internal
@@ -1756,7 +1743,7 @@ class ApplicationInsightsClient extends coreClient__namespace.ServiceClient {
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.11`;
+        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.13`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -1912,14 +1899,21 @@ class Context {
         [Context.nodeVersion] = node.split(".");
         Context.opentelemetryVersion = core.SDK_INFO[semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_VERSION];
         Context.sdkVersion = packageVersion;
-        this.tags[KnownContextTagKeys.AiInternalSdkVersion] = `node${Context.nodeVersion}:otel${Context.opentelemetryVersion}:ext${Context.sdkVersion}`;
+        let prefix = process.env["AZURE_MONITOR_AGENT_PREFIX"]
+            ? process.env["AZURE_MONITOR_AGENT_PREFIX"]
+            : "";
+        let version = process.env["AZURE_MONITOR_DISTRO_VERSION"]
+            ? `dst${process.env["AZURE_MONITOR_DISTRO_VERSION"]}`
+            : `ext${Context.sdkVersion}`;
+        let internalSdkVersion = `${prefix}node${Context.nodeVersion}:otel${Context.opentelemetryVersion}:${version}`;
+        this.tags[KnownContextTagKeys.AiInternalSdkVersion] = internalSdkVersion;
     }
 }
 Context.sdkVersion = null;
 Context.opentelemetryVersion = null;
 Context.nodeVersion = "";
 /**
- * Singleton Context instance.
+ * Singleton Context instance
  * @internal
  */
 function getInstance$1() {
@@ -2505,7 +2499,7 @@ class AzureMonitorBaseExporter {
         }
         this._sender = new HttpSender(this._endpointUrl, this._options);
         this._persister = new FileSystemPersist(this._instrumentationKey, this._options);
-        if (!this._isStatsbeatExporter) {
+        if (!this._isStatsbeatExporter && !process.env[ENV_DISABLE_STATSBEAT]) {
             // Initialize statsbeatMetrics
             this._networkStatsbeatMetrics = new NetworkStatsbeatMetrics({
                 instrumentationKey: this._instrumentationKey,
@@ -2695,29 +2689,80 @@ function createTagsFromResource(resource) {
     const context = getInstance$1();
     const tags = Object.assign({}, context.tags);
     if (resource && resource.attributes) {
-        const serviceName = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAME];
-        const serviceNamespace = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAMESPACE];
-        if (serviceName) {
+        tags[KnownContextTagKeys.AiCloudRole] = getCloudRole(resource);
+        tags[KnownContextTagKeys.AiCloudRoleInstance] = getCloudRoleInstance(resource);
+        const endUserId = resource.attributes[semanticConventions.SemanticAttributes.ENDUSER_ID];
+        if (endUserId) {
+            tags[KnownContextTagKeys.AiUserId] = String(endUserId);
+        }
+    }
+    return tags;
+}
+function getCloudRole(resource) {
+    let cloudRole = "";
+    // Service attributes
+    const serviceName = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAME];
+    const serviceNamespace = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAMESPACE];
+    if (serviceName) {
+        // Custom Service name provided by customer is highest precedence
+        if (!String(serviceName).startsWith("unknown_service")) {
             if (serviceNamespace) {
-                tags[KnownContextTagKeys.AiCloudRole] = `${serviceNamespace}.${serviceName}`;
+                return `${serviceNamespace}.${serviceName}`;
             }
             else {
-                tags[KnownContextTagKeys.AiCloudRole] = String(serviceName);
+                return String(serviceName);
             }
         }
-        const serviceInstanceId = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_INSTANCE_ID];
-        if (serviceInstanceId) {
-            tags[KnownContextTagKeys.AiCloudRoleInstance] = String(serviceInstanceId);
-        }
         else {
-            tags[KnownContextTagKeys.AiCloudRoleInstance] = os__default["default"] && os__default["default"].hostname();
-        }
-        const endUserId = resource.attributes[semanticConventions.SemanticAttributes.ENDUSER_ID];
-        if (endUserId) {
-            tags[KnownContextTagKeys.AiUserId] = String(endUserId);
+            // Service attributes will be only used if K8S attributes are not present
+            if (serviceNamespace) {
+                cloudRole = `${serviceNamespace}.${serviceName}`;
+            }
+            else {
+                cloudRole = String(serviceName);
+            }
         }
     }
-    return tags;
+    // Kubernetes attributes should take precedence
+    const kubernetesDeploymentName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_DEPLOYMENT_NAME];
+    if (kubernetesDeploymentName) {
+        return String(kubernetesDeploymentName);
+    }
+    const kuberneteReplicasetName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_REPLICASET_NAME];
+    if (kuberneteReplicasetName) {
+        return String(kuberneteReplicasetName);
+    }
+    const kubernetesStatefulSetName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_STATEFULSET_NAME];
+    if (kubernetesStatefulSetName) {
+        return String(kubernetesStatefulSetName);
+    }
+    const kubernetesJobName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_JOB_NAME];
+    if (kubernetesJobName) {
+        return String(kubernetesJobName);
+    }
+    const kubernetesCronjobName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_CRONJOB_NAME];
+    if (kubernetesCronjobName) {
+        return String(kubernetesCronjobName);
+    }
+    const kubernetesDaemonsetName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_DAEMONSET_NAME];
+    if (kubernetesDaemonsetName) {
+        return String(kubernetesDaemonsetName);
+    }
+    return cloudRole;
+}
+function getCloudRoleInstance(resource) {
+    // Kubernetes attributes should take precedence
+    const kubernetesPodName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_POD_NAME];
+    if (kubernetesPodName) {
+        return String(kubernetesPodName);
+    }
+    // Service attributes
+    const serviceInstanceId = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_INSTANCE_ID];
+    if (serviceInstanceId) {
+        return String(serviceInstanceId);
+    }
+    // Default
+    return os__default["default"] && os__default["default"].hostname();
 }
 function isSqlDB(dbSystem) {
     return (dbSystem === semanticConventions.DbSystemValues.DB2 ||
@@ -2794,6 +2839,41 @@ function getDependencyTarget(attributes) {
     }
     return "";
 }
+function createResourceMetricEnvelope(resource, instrumentationKey) {
+    if (resource && resource.attributes) {
+        const tags = createTagsFromResource(resource);
+        const resourceAttributes = {};
+        for (const key of Object.keys(resource.attributes)) {
+            // Avoid duplication ignoring fields already mapped.
+            if (!(key.startsWith("_MS.") ||
+                key == semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_VERSION ||
+                key == semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_LANGUAGE ||
+                key == semanticConventions.SemanticResourceAttributes.TELEMETRY_SDK_NAME)) {
+                resourceAttributes[key] = resource.attributes[key];
+            }
+        }
+        // Only send event when resource attributes are available
+        if (Object.keys(resourceAttributes).length > 0) {
+            let envelope = {
+                name: "_APPRESOURCEPREVIEW_",
+                time: new Date(),
+                sampleRate: 100,
+                instrumentationKey: instrumentationKey,
+                version: 1,
+                data: {
+                    baseType: "MetricData",
+                    baseData: {
+                        version: 2,
+                        properties: resourceAttributes,
+                    },
+                },
+                tags: tags,
+            };
+            return envelope;
+        }
+    }
+    return;
+}
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -2884,7 +2964,7 @@ function createTagsFromSpan(span) {
             }
             else if (httpUrl) {
                 try {
-                    let url$1 = new url.URL(String(httpUrl));
+                    const url$1 = new url.URL(String(httpUrl));
                     tags[KnownContextTagKeys.AiOperationName] = `${httpMethod} ${url$1.pathname}`;
                 }
                 catch (ex) { }
@@ -2910,19 +2990,23 @@ function createPropertiesFromSpanAttributes(attributes) {
     const properties = {};
     if (attributes) {
         for (const key of Object.keys(attributes)) {
-            if (!(key.startsWith("http.") ||
-                key.startsWith("rpc.") ||
-                key.startsWith("db.") ||
-                key.startsWith("peer.") ||
-                key.startsWith("message.") ||
-                key.startsWith("messaging.") ||
-                key.startsWith("enduser.") ||
-                key.startsWith("net.") ||
-                key.startsWith("exception.") ||
-                key.startsWith("thread.") ||
-                key.startsWith("faas.") ||
-                key.startsWith("code.") ||
-                key.startsWith("_MS."))) {
+            // Avoid duplication ignoring fields already mapped.
+            if (!(key.startsWith("_MS.") ||
+                key == semanticConventions.SemanticAttributes.NET_PEER_IP ||
+                key == semanticConventions.SemanticAttributes.NET_PEER_NAME ||
+                key == semanticConventions.SemanticAttributes.PEER_SERVICE ||
+                key == semanticConventions.SemanticAttributes.HTTP_METHOD ||
+                key == semanticConventions.SemanticAttributes.HTTP_URL ||
+                key == semanticConventions.SemanticAttributes.HTTP_STATUS_CODE ||
+                key == semanticConventions.SemanticAttributes.HTTP_ROUTE ||
+                key == semanticConventions.SemanticAttributes.HTTP_HOST ||
+                key == semanticConventions.SemanticAttributes.HTTP_URL ||
+                key == semanticConventions.SemanticAttributes.DB_SYSTEM ||
+                key == semanticConventions.SemanticAttributes.DB_STATEMENT ||
+                key == semanticConventions.SemanticAttributes.DB_OPERATION ||
+                key == semanticConventions.SemanticAttributes.DB_NAME ||
+                key == semanticConventions.SemanticAttributes.RPC_SYSTEM ||
+                key == semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE)) {
                 properties[key] = attributes[key];
             }
         }
@@ -2965,7 +3049,7 @@ function createDependencyData(span) {
         const httpUrl = span.attributes[semanticConventions.SemanticAttributes.HTTP_URL];
         if (httpUrl) {
             try {
-                let dependencyUrl = new url.URL(String(httpUrl));
+                const dependencyUrl = new url.URL(String(httpUrl));
                 remoteDependencyData.name = `${httpMethod} ${dependencyUrl.pathname}`;
             }
             catch (ex) { }
@@ -2980,11 +3064,11 @@ function createDependencyData(span) {
         if (target) {
             try {
                 // Remove default port
-                let portRegex = new RegExp(/(https?)(:\/\/.*)(:\d+)(\S*)/);
-                let res = portRegex.exec(target);
+                const portRegex = new RegExp(/(https?)(:\/\/.*)(:\d+)(\S*)/);
+                const res = portRegex.exec(target);
                 if (res != null) {
-                    let protocol = res[1];
-                    let port = res[3];
+                    const protocol = res[1];
+                    const port = res[3];
                     if ((protocol == "https" && port == ":443") || (protocol == "http" && port == ":80")) {
                         // Drop port
                         target = res[1] + res[2] + res[4];
@@ -3024,7 +3108,7 @@ function createDependencyData(span) {
         else if (dbOperation) {
             remoteDependencyData.data = String(dbOperation);
         }
-        let target = getDependencyTarget(span.attributes);
+        const target = getDependencyTarget(span.attributes);
         const dbName = span.attributes[semanticConventions.SemanticAttributes.DB_NAME];
         if (target) {
             remoteDependencyData.target = dbName ? `${target}|${dbName}` : `${target}`;
@@ -3040,7 +3124,7 @@ function createDependencyData(span) {
         if (grpcStatusCode) {
             remoteDependencyData.resultCode = String(grpcStatusCode);
         }
-        let target = getDependencyTarget(span.attributes);
+        const target = getDependencyTarget(span.attributes);
         if (target) {
             remoteDependencyData.target = `${target}`;
         }
@@ -3137,18 +3221,18 @@ function readableSpanToEnvelope(span, ikey) {
  * @internal
  */
 function spanEventsToEnvelopes(span, ikey) {
-    let envelopes = [];
+    const envelopes = [];
     if (span.events) {
         span.events.forEach((event) => {
             var _a;
             let baseType;
-            let time = new Date(core.hrTimeToMilliseconds(event.time));
+            const time = new Date(core.hrTimeToMilliseconds(event.time));
             let name = "";
             let baseData;
             const properties = createPropertiesFromSpanAttributes(event.attributes);
-            let tags = createTagsFromResource(span.resource);
+            const tags = createTagsFromResource(span.resource);
             tags[KnownContextTagKeys.AiOperationId] = span.spanContext().traceId;
-            let spanId = (_a = span.spanContext()) === null || _a === void 0 ? void 0 : _a.spanId;
+            const spanId = (_a = span.spanContext()) === null || _a === void 0 ? void 0 : _a.spanId;
             if (spanId) {
                 tags[KnownContextTagKeys.AiOperationParentId] = spanId;
             }
@@ -3166,22 +3250,22 @@ function spanEventsToEnvelopes(span, ikey) {
                     if (stack) {
                         hasFullStack = true;
                     }
-                    let exceptionMsg = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
+                    const exceptionMsg = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
                     if (exceptionMsg) {
                         message = String(exceptionMsg);
                     }
-                    let escaped = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED];
+                    const escaped = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED];
                     if (escaped != undefined) {
                         properties[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED] = String(escaped);
                     }
                 }
-                let exceptionDetails = {
+                const exceptionDetails = {
                     typeName: typeName,
                     message: message,
                     stack: stack,
                     hasFullStack: hasFullStack,
                 };
-                let exceptionData = {
+                const exceptionData = {
                     exceptions: [exceptionDetails],
                     version: 2,
                     properties: properties,
@@ -3191,7 +3275,7 @@ function spanEventsToEnvelopes(span, ikey) {
             else {
                 name = "Microsoft.ApplicationInsights.Message";
                 baseType = "MessageData";
-                let messageData = {
+                const messageData = {
                     message: event.name,
                     version: 2,
                     properties: properties,
@@ -3202,7 +3286,7 @@ function spanEventsToEnvelopes(span, ikey) {
             if (span.attributes[AzureMonitorSampleRate]) {
                 sampleRate = Number(span.attributes[AzureMonitorSampleRate]);
             }
-            let env = {
+            const env = {
                 name: name,
                 time: time,
                 instrumentationKey: ikey,
@@ -3249,15 +3333,23 @@ class AzureMonitorTraceExporter extends AzureMonitorBaseExporter {
             return;
         }
         api.diag.info(`Exporting ${spans.length} span(s). Converting to envelopes...`);
-        let envelopes = [];
-        spans.forEach((span) => {
-            envelopes.push(readableSpanToEnvelope(span, this._instrumentationKey));
-            let spanEventEnvelopes = spanEventsToEnvelopes(span, this._instrumentationKey);
-            if (spanEventEnvelopes.length > 0) {
-                envelopes.push(...spanEventEnvelopes);
-            }
-        });
-        resultCallback(await this._exportEnvelopes(envelopes));
+        if (spans.length > 0) {
+            let envelopes = [];
+            const resourceMetricEnvelope = createResourceMetricEnvelope(spans[0].resource, this._instrumentationKey);
+            if (resourceMetricEnvelope) {
+                envelopes.push(resourceMetricEnvelope);
+            }
+            spans.forEach((span) => {
+                envelopes.push(readableSpanToEnvelope(span, this._instrumentationKey));
+                let spanEventEnvelopes = spanEventsToEnvelopes(span, this._instrumentationKey);
+                if (spanEventEnvelopes.length > 0) {
+                    envelopes.push(...spanEventEnvelopes);
+                }
+            });
+            resultCallback(await this._exportEnvelopes(envelopes));
+        }
+        // No data to export
+        resultCallback({ code: core.ExportResultCode.SUCCESS });
     }
     /**
      * Shutdown AzureMonitorTraceExporter.
@@ -3297,20 +3389,13 @@ function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
     }
     metrics.scopeMetrics.forEach((scopeMetric) => {
         scopeMetric.metrics.forEach((metric) => {
-            var _a, _b;
-            const isStandardMetric = (_b = (_a = metric.descriptor) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.startsWith("azureMonitor.");
             metric.dataPoints.forEach((dataPoint) => {
                 let baseData = {
                     metrics: [],
                     version: 2,
                     properties: {},
                 };
-                if (isStandardMetric) {
-                    baseData.properties = createStandardMetricsProperties(metric.descriptor.name, dataPoint.attributes, tags);
-                }
-                else {
-                    baseData.properties = createPropertiesFromMetricAttributes(dataPoint.attributes);
-                }
+                baseData.properties = createPropertiesFromMetricAttributes(dataPoint.attributes);
                 var metricDataPoint = {
                     name: metric.descriptor.name,
                     value: 0,
@@ -3346,37 +3431,6 @@ function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
     });
     return envelopes;
 }
-function createStandardMetricsProperties(name, attributes, tags) {
-    const properties = {};
-    properties[PreAggregatedMetricPropertyNames.IsAutocollected] = "True";
-    properties[PreAggregatedMetricPropertyNames.cloudRoleInstance] =
-        tags[KnownContextTagKeys.AiCloudRoleInstance];
-    properties[PreAggregatedMetricPropertyNames.cloudRoleName] =
-        tags[KnownContextTagKeys.AiCloudRole];
-    if (name == StandardMetrics.HTTP_REQUEST_DURATION) {
-        properties[PreAggregatedMetricPropertyNames.metricId] = StandardMetricIds.REQUEST_DURATION;
-        let statusCode = String(attributes["http.status_code"]);
-        properties[PreAggregatedMetricPropertyNames.requestResultCode] = statusCode;
-        properties[PreAggregatedMetricPropertyNames.requestSuccess] =
-            statusCode == "200" ? "True" : "False";
-    }
-    else if (name == StandardMetrics.HTTP_DEPENDENCY_DURATION) {
-        properties[PreAggregatedMetricPropertyNames.metricId] = StandardMetricIds.DEPENDENCY_DURATION;
-        let statusCode = String(attributes["http.status_code"]);
-        properties[PreAggregatedMetricPropertyNames.dependencyTarget] = getDependencyTarget(attributes);
-        properties[PreAggregatedMetricPropertyNames.dependencyResultCode] = statusCode;
-        properties[PreAggregatedMetricPropertyNames.dependencyType] = "http";
-        properties[PreAggregatedMetricPropertyNames.dependencySuccess] =
-            statusCode == "200" ? "True" : "False";
-    }
-    else if (name == StandardMetrics.TRACE_COUNT) {
-        properties[PreAggregatedMetricPropertyNames.metricId] = StandardMetricIds.TRACE_COUNT;
-    }
-    else if (name == StandardMetrics.EXCEPTION_COUNT) {
-        properties[PreAggregatedMetricPropertyNames.metricId] = StandardMetricIds.EXCEPTION_COUNT;
-    }
-    return properties;
-}
 
 // Copyright (c) Microsoft Corporation.
 /**
@@ -3436,6 +3490,224 @@ class AzureMonitorMetricExporter extends AzureMonitorBaseExporter {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+/**
+ * Log to Azure envelope parsing.
+ * @internal
+ */
+function logToEnvelope(log, ikey) {
+    const time = log.hrTime ? new Date(core.hrTimeToMilliseconds(log.hrTime)) : new Date();
+    let sampleRate = 100;
+    const instrumentationKey = ikey;
+    const tags = createTagsFromLog(log);
+    const [properties, measurements] = createPropertiesFromLog(log);
+    let name;
+    let baseType;
+    let baseData;
+    if (!log.attributes[ApplicationInsightsBaseType]) {
+        // Get Exception attributes if available
+        let exceptionType = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_TYPE];
+        if (exceptionType) {
+            let exceptionMessage = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
+            let exceptionStacktrace = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE];
+            name = ApplicationInsightsExceptionName;
+            baseType = ApplicationInsightsExceptionBaseType;
+            let exceptionDetails = {
+                typeName: String(exceptionType),
+                message: String(exceptionMessage),
+                hasFullStack: exceptionStacktrace ? true : false,
+                stack: String(exceptionStacktrace),
+            };
+            const exceptionData = {
+                exceptions: [exceptionDetails],
+                severityLevel: String(getSeverity(log.severityNumber)),
+                version: 2,
+            };
+            baseData = exceptionData;
+        }
+        else {
+            name = ApplicationInsightsMessageName;
+            baseType = ApplicationInsightsMessageBaseType;
+            const messageData = {
+                message: String(log.body),
+                severityLevel: String(getSeverity(log.severityNumber)),
+                version: 2,
+            };
+            baseData = messageData;
+        }
+    }
+    else {
+        // If Legacy Application Insights Log
+        baseType = String(log.attributes[ApplicationInsightsBaseType]);
+        name = getLegacyApplicationInsightsName(log);
+        baseData = getLegacyApplicationInsightsBaseData(log);
+        if (!baseData) {
+            // Failed to parse log
+            return;
+        }
+    }
+    return {
+        name,
+        sampleRate,
+        time,
+        instrumentationKey,
+        tags,
+        version: 1,
+        data: {
+            baseType,
+            baseData: Object.assign(Object.assign({}, baseData), { properties,
+                measurements }),
+        },
+    };
+}
+function createTagsFromLog(log) {
+    var _a, _b;
+    const tags = createTagsFromResource(log.resource);
+    if ((_a = log.spanContext) === null || _a === void 0 ? void 0 : _a.traceId) {
+        tags[KnownContextTagKeys.AiOperationId] = log.spanContext.traceId;
+    }
+    if ((_b = log.spanContext) === null || _b === void 0 ? void 0 : _b.spanId) {
+        tags[KnownContextTagKeys.AiOperationParentId] = log.spanContext.spanId;
+    }
+    return tags;
+}
+function createPropertiesFromLog(log) {
+    const measurements = {};
+    const properties = {};
+    if (log.attributes) {
+        for (const key of Object.keys(log.attributes)) {
+            // Avoid duplication ignoring fields already mapped.
+            if (!(key.startsWith("_MS.") ||
+                key == semanticConventions.SemanticAttributes.EXCEPTION_TYPE ||
+                key == semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE ||
+                key == semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE)) {
+                properties[key] = log.attributes[key];
+            }
+        }
+    }
+    return [properties, measurements];
+}
+// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#field-severitynumber
+function getSeverity(severityNumber) {
+    if (severityNumber) {
+        if (severityNumber > 0 && severityNumber < 9) {
+            return KnownSeverityLevel.Verbose;
+        }
+        else if (severityNumber >= 9 && severityNumber < 13) {
+            return KnownSeverityLevel.Information;
+        }
+        else if (severityNumber >= 13 && severityNumber < 17) {
+            return KnownSeverityLevel.Warning;
+        }
+        else if (severityNumber >= 17 && severityNumber < 21) {
+            return KnownSeverityLevel.Error;
+        }
+        else if (severityNumber >= 21 && severityNumber < 25) {
+            return KnownSeverityLevel.Critical;
+        }
+    }
+    return;
+}
+function getLegacyApplicationInsightsName(log) {
+    let name = "";
+    switch (log.attributes[ApplicationInsightsBaseType]) {
+        case ApplicationInsightsAvailabilityBaseType:
+            name = ApplicationInsightsAvailabilityName;
+            break;
+        case ApplicationInsightsExceptionBaseType:
+            name = ApplicationInsightsExceptionName;
+            break;
+        case ApplicationInsightsMessageBaseType:
+            name = ApplicationInsightsMessageName;
+            break;
+        case ApplicationInsightsPageViewBaseType:
+            name = ApplicationInsightsPageViewName;
+            break;
+        case ApplicationInsightsEventBaseType:
+            name = ApplicationInsightsEventName;
+            break;
+    }
+    return name;
+}
+function getLegacyApplicationInsightsBaseData(log) {
+    let baseData = {
+        version: 2,
+    };
+    if (log.body) {
+        try {
+            switch (log.attributes[ApplicationInsightsBaseType]) {
+                case ApplicationInsightsAvailabilityBaseType:
+                    baseData = JSON.parse(log.body);
+                    break;
+                case ApplicationInsightsExceptionBaseType:
+                    baseData = JSON.parse(log.body);
+                    break;
+                case ApplicationInsightsMessageBaseType:
+                    baseData = JSON.parse(log.body);
+                    break;
+                case ApplicationInsightsPageViewBaseType:
+                    baseData = JSON.parse(log.body);
+                    break;
+                case ApplicationInsightsEventBaseType:
+                    baseData = JSON.parse(log.body);
+                    break;
+            }
+        }
+        catch (err) {
+            api.diag.error("AzureMonitorLogExporter failed to parse Application Insights Telemetry");
+        }
+    }
+    return baseData;
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Azure Monitor OpenTelemetry Log Exporter.
+ */
+class AzureMonitorLogExporter extends AzureMonitorBaseExporter {
+    /**
+     * Initializes a new instance of the AzureMonitorLogExporter class.
+     * @param AzureExporterConfig - Exporter configuration.
+     */
+    constructor(options = {}) {
+        super(options);
+        /**
+         * Flag to determine if Exporter is shutdown.
+         */
+        this._isShutdown = false;
+        api.diag.debug("AzureMonitorLogExporter was successfully setup");
+    }
+    /**
+     * Export OpenTelemetry logs.
+     * @param logs - Logs to export.
+     * @param resultCallback - Result callback.
+     */
+    async export(logs, resultCallback) {
+        if (this._isShutdown) {
+            api.diag.info("Exporter shut down. Failed to export spans.");
+            setTimeout(() => resultCallback({ code: core.ExportResultCode.FAILED }), 0);
+            return;
+        }
+        api.diag.info(`Exporting ${logs.length} logs(s). Converting to envelopes...`);
+        let envelopes = [];
+        logs.forEach((log) => {
+            let envelope = logToEnvelope(log, this._instrumentationKey);
+            if (envelope) {
+                envelopes.push(envelope);
+            }
+        });
+        resultCallback(await this._exportEnvelopes(envelopes));
+    }
+    /**
+     * Shutdown AzureMonitorLogExporter.
+     */
+    async shutdown() {
+        this._isShutdown = true;
+        api.diag.info("AzureMonitorLogExporter shutting down");
+        return this._shutdown();
+    }
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * Azure Monitor Statsbeat Exporter
@@ -3484,6 +3756,7 @@ class AzureMonitorStatsbeatExporter extends AzureMonitorBaseExporter {
 
 exports.ApplicationInsightsSampler = ApplicationInsightsSampler;
 exports.AzureMonitorBaseExporter = AzureMonitorBaseExporter;
+exports.AzureMonitorLogExporter = AzureMonitorLogExporter;
 exports.AzureMonitorMetricExporter = AzureMonitorMetricExporter;
 exports.AzureMonitorStatsbeatExporter = AzureMonitorStatsbeatExporter;
 exports.AzureMonitorTraceExporter = AzureMonitorTraceExporter;