@azure/monitor-opentelemetry-exporter 1.0.0-beta.21 → 1.0.0-beta.23

package/README.md

@@ -115,6 +115,8 @@ You can enable sampling to limit the amount of telemetry records you receive. In
 const { ApplicationInsightsSampler } = require("@azure/monitor-opentelemetry-exporter");
 const { BatchSpanProcessor } = require("@opentelemetry/sdk-trace-base");
 const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
+const { Resource } = require("@opentelemetry/resources"); 
+const { SemanticResourceAttributes } = require("@opentelemetry/semantic-conventions"); 
 
 // Sampler expects a sample rate of between 0 and 1 inclusive
 // A rate of 0.75 means approximately 75 % of your traces will be sent

package/dist/index.js

@@ -60,7 +60,7 @@ const TIME_SINCE_ENQUEUED = "timeSinceEnqueued";
  * AzureMonitorTraceExporter version.
  * @internal
  */
-const packageVersion = "1.0.0-beta.21";
+const packageVersion = "1.0.0-beta.23";
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["InProc"] = "InProc";
@@ -1814,7 +1814,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.21`;
+        const packageDetails = `azsdk-js-monitor-opentelemetry-exporter/1.0.0-beta.23`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -2038,6 +2038,43 @@ class StatsbeatMetrics {
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
+/**
+ * Performance Counter OpenTelemetry compliant names.
+ * @internal
+ */
+var OTelPerformanceCounterNames;
+(function (OTelPerformanceCounterNames) {
+    OTelPerformanceCounterNames["PRIVATE_BYTES"] = "Private_Bytes";
+    OTelPerformanceCounterNames["AVAILABLE_BYTES"] = "Available_Bytes";
+    OTelPerformanceCounterNames["PROCESSOR_TIME"] = "Processor_Time";
+    OTelPerformanceCounterNames["PROCESS_TIME"] = "Process_Time";
+    OTelPerformanceCounterNames["REQUEST_RATE"] = "Request_Rate";
+    OTelPerformanceCounterNames["REQUEST_DURATION"] = "Request_Execution_Time";
+})(OTelPerformanceCounterNames || (OTelPerformanceCounterNames = {}));
+/**
+ * Breeze Performance Counter names.
+ * @internal
+ */
+var BreezePerformanceCounterNames;
+(function (BreezePerformanceCounterNames) {
+    BreezePerformanceCounterNames["PRIVATE_BYTES"] = "\\Process(??APP_WIN32_PROC??)\\Private Bytes";
+    BreezePerformanceCounterNames["AVAILABLE_BYTES"] = "\\Memory\\Available Bytes";
+    BreezePerformanceCounterNames["PROCESSOR_TIME"] = "\\Processor(_Total)\\% Processor Time";
+    BreezePerformanceCounterNames["PROCESS_TIME"] = "\\Process(??APP_WIN32_PROC??)\\% Processor Time";
+    BreezePerformanceCounterNames["REQUEST_RATE"] = "\\ASP.NET Applications(??APP_W3SVC_PROC??)\\Requests/Sec";
+    BreezePerformanceCounterNames["REQUEST_DURATION"] = "\\ASP.NET Applications(??APP_W3SVC_PROC??)\\Request Execution Time";
+})(BreezePerformanceCounterNames || (BreezePerformanceCounterNames = {}));
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+const breezePerformanceCountersMap = new Map([
+    [OTelPerformanceCounterNames.PRIVATE_BYTES, BreezePerformanceCounterNames.PRIVATE_BYTES],
+    [OTelPerformanceCounterNames.AVAILABLE_BYTES, BreezePerformanceCounterNames.AVAILABLE_BYTES],
+    [OTelPerformanceCounterNames.PROCESSOR_TIME, BreezePerformanceCounterNames.PROCESSOR_TIME],
+    [OTelPerformanceCounterNames.PROCESS_TIME, BreezePerformanceCounterNames.PROCESS_TIME],
+    [OTelPerformanceCounterNames.REQUEST_RATE, BreezePerformanceCounterNames.REQUEST_RATE],
+    [OTelPerformanceCounterNames.REQUEST_DURATION, BreezePerformanceCounterNames.REQUEST_DURATION],
+]);
 function createPropertiesFromMetricAttributes(attributes) {
     const properties = {};
     if (attributes) {
@@ -2072,8 +2109,12 @@ function resourceMetricsToEnvelope(metrics, ikey, isStatsbeat) {
                     properties: {},
                 };
                 baseData.properties = createPropertiesFromMetricAttributes(dataPoint.attributes);
+                let perfCounterName;
+                if (breezePerformanceCountersMap.has(metric.descriptor.name)) {
+                    perfCounterName = breezePerformanceCountersMap.get(metric.descriptor.name);
+                }
                 const metricDataPoint = {
-                    name: metric.descriptor.name,
+                    name: perfCounterName ? perfCounterName : metric.descriptor.name,
                     value: 0,
                     dataPointType: "Aggregation",
                 };
@@ -2411,7 +2452,6 @@ let instance$1 = null;
 class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
     constructor(options) {
         super();
-        this.AZURE_MONITOR_STATSBEAT_FEATURES = process.env.AZURE_MONITOR_STATSBEAT_FEATURES;
         this.statsCollectionLongInterval = 86400000; // 1 day
         this.attach = "Manual";
         this.feature = 0;
@@ -2421,15 +2461,7 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
         const exporterConfig = {
             connectionString: this.connectionString,
         };
-        if (this.AZURE_MONITOR_STATSBEAT_FEATURES) {
-            try {
-                this.feature = JSON.parse(this.AZURE_MONITOR_STATSBEAT_FEATURES).feature;
-                this.instrumentation = JSON.parse(this.AZURE_MONITOR_STATSBEAT_FEATURES).instrumentation;
-            }
-            catch (error) {
-                api.diag.error(`LongIntervalStatsbeat: Failed to parse features/instrumentations (error ${error})`);
-            }
-        }
+        this.setFeatures();
         this.longIntervalStatsbeatMeterProvider = new sdkMetrics.MeterProvider();
         this.longIntervalAzureExporter = new AzureMonitorStatsbeatExporter(exporterConfig);
         // Export Long Interval Statsbeats every day
@@ -2467,9 +2499,7 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
             await this.getResourceProvider();
             // Add long interval observable callbacks
             this.attachStatsbeatGauge.addCallback(this.attachCallback.bind(this));
-            this.longIntervalStatsbeatMeter.addBatchObservableCallback(this.featureCallback.bind(this), [
-                this.featureStatsbeatGauge,
-            ]);
+            this.longIntervalStatsbeatMeter.addBatchObservableCallback(this.getEnvironmentStatus.bind(this), [this.featureStatsbeatGauge]);
             // Export Feature/Attach Statsbeat once upon app initialization
             this.longIntervalAzureExporter.export((await this.longIntervalMetricReader.collect()).resourceMetrics, (result) => {
                 if (result.code !== core.ExportResultCode.SUCCESS) {
@@ -2481,7 +2511,8 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
             api.diag.debug("Call to get the resource provider failed.");
         }
     }
-    featureCallback(observableResult) {
+    getEnvironmentStatus(observableResult) {
+        this.setFeatures();
         let attributes;
         if (this.instrumentation) {
             attributes = Object.assign(Object.assign({}, this.commonProperties), { feature: this.instrumentation, type: StatsbeatFeatureType.INSTRUMENTATION });
@@ -2492,6 +2523,18 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
             observableResult.observe(this.featureStatsbeatGauge, 1, Object.assign({}, attributes));
         }
     }
+    setFeatures() {
+        let statsbeatFeatures = process.env.AZURE_MONITOR_STATSBEAT_FEATURES;
+        if (statsbeatFeatures) {
+            try {
+                this.feature = JSON.parse(statsbeatFeatures).feature;
+                this.instrumentation = JSON.parse(statsbeatFeatures).instrumentation;
+            }
+            catch (error) {
+                api.diag.error(`LongIntervalStatsbeat: Failed to parse features/instrumentations (error ${error})`);
+            }
+        }
+    }
     attachCallback(observableResult) {
         const attributes = Object.assign(Object.assign({}, this.commonProperties), this.attachProperties);
         observableResult.observe(1, attributes);
@@ -2869,9 +2912,14 @@ function createTagsFromResource(resource) {
     if (resource && resource.attributes) {
         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);
+        if (resource.attributes[semanticConventions.SEMRESATTRS_DEVICE_ID]) {
+            tags[KnownContextTagKeys.AiDeviceId] = String(resource.attributes[semanticConventions.SEMRESATTRS_DEVICE_ID]);
+        }
+        if (resource.attributes[semanticConventions.SEMRESATTRS_DEVICE_MODEL_NAME]) {
+            tags[KnownContextTagKeys.AiDeviceModel] = String(resource.attributes[semanticConventions.SEMRESATTRS_DEVICE_MODEL_NAME]);
+        }
+        if (resource.attributes[semanticConventions.SEMRESATTRS_SERVICE_VERSION]) {
+            tags[KnownContextTagKeys.AiApplicationVer] = String(resource.attributes[semanticConventions.SEMRESATTRS_SERVICE_VERSION]);
         }
     }
     return tags;
@@ -2879,8 +2927,8 @@ function createTagsFromResource(resource) {
 function getCloudRole(resource) {
     let cloudRole = "";
     // Service attributes
-    const serviceName = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAME];
-    const serviceNamespace = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_NAMESPACE];
+    const serviceName = resource.attributes[semanticConventions.SEMRESATTRS_SERVICE_NAME];
+    const serviceNamespace = resource.attributes[semanticConventions.SEMRESATTRS_SERVICE_NAMESPACE];
     if (serviceName) {
         // Custom Service name provided by customer is highest precedence
         if (!String(serviceName).startsWith("unknown_service")) {
@@ -2902,27 +2950,27 @@ function getCloudRole(resource) {
         }
     }
     // Kubernetes attributes should take precedence
-    const kubernetesDeploymentName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_DEPLOYMENT_NAME];
+    const kubernetesDeploymentName = resource.attributes[semanticConventions.SEMRESATTRS_K8S_DEPLOYMENT_NAME];
     if (kubernetesDeploymentName) {
         return String(kubernetesDeploymentName);
     }
-    const kuberneteReplicasetName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_REPLICASET_NAME];
+    const kuberneteReplicasetName = resource.attributes[semanticConventions.SEMRESATTRS_K8S_REPLICASET_NAME];
     if (kuberneteReplicasetName) {
         return String(kuberneteReplicasetName);
     }
-    const kubernetesStatefulSetName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_STATEFULSET_NAME];
+    const kubernetesStatefulSetName = resource.attributes[semanticConventions.SEMRESATTRS_K8S_STATEFULSET_NAME];
     if (kubernetesStatefulSetName) {
         return String(kubernetesStatefulSetName);
     }
-    const kubernetesJobName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_JOB_NAME];
+    const kubernetesJobName = resource.attributes[semanticConventions.SEMRESATTRS_K8S_JOB_NAME];
     if (kubernetesJobName) {
         return String(kubernetesJobName);
     }
-    const kubernetesCronjobName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_CRONJOB_NAME];
+    const kubernetesCronjobName = resource.attributes[semanticConventions.SEMRESATTRS_K8S_CRONJOB_NAME];
     if (kubernetesCronjobName) {
         return String(kubernetesCronjobName);
     }
-    const kubernetesDaemonsetName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_DAEMONSET_NAME];
+    const kubernetesDaemonsetName = resource.attributes[semanticConventions.SEMRESATTRS_K8S_DAEMONSET_NAME];
     if (kubernetesDaemonsetName) {
         return String(kubernetesDaemonsetName);
     }
@@ -2930,12 +2978,12 @@ function getCloudRole(resource) {
 }
 function getCloudRoleInstance(resource) {
     // Kubernetes attributes should take precedence
-    const kubernetesPodName = resource.attributes[semanticConventions.SemanticResourceAttributes.K8S_POD_NAME];
+    const kubernetesPodName = resource.attributes[semanticConventions.SEMRESATTRS_K8S_POD_NAME];
     if (kubernetesPodName) {
         return String(kubernetesPodName);
     }
     // Service attributes
-    const serviceInstanceId = resource.attributes[semanticConventions.SemanticResourceAttributes.SERVICE_INSTANCE_ID];
+    const serviceInstanceId = resource.attributes[semanticConventions.SEMRESATTRS_SERVICE_INSTANCE_ID];
     if (serviceInstanceId) {
         return String(serviceInstanceId);
     }
@@ -2943,43 +2991,43 @@ function getCloudRoleInstance(resource) {
     return os$1 && os$1.hostname();
 }
 function isSqlDB(dbSystem) {
-    return (dbSystem === semanticConventions.DbSystemValues.DB2 ||
-        dbSystem === semanticConventions.DbSystemValues.DERBY ||
-        dbSystem === semanticConventions.DbSystemValues.MARIADB ||
-        dbSystem === semanticConventions.DbSystemValues.MSSQL ||
-        dbSystem === semanticConventions.DbSystemValues.ORACLE ||
-        dbSystem === semanticConventions.DbSystemValues.SQLITE ||
-        dbSystem === semanticConventions.DbSystemValues.OTHER_SQL ||
-        dbSystem === semanticConventions.DbSystemValues.HSQLDB ||
-        dbSystem === semanticConventions.DbSystemValues.H2);
+    return (dbSystem === semanticConventions.DBSYSTEMVALUES_DB2 ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_DERBY ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_MARIADB ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_MSSQL ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_ORACLE ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_SQLITE ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_OTHER_SQL ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_HSQLDB ||
+        dbSystem === semanticConventions.DBSYSTEMVALUES_H2);
 }
 function getUrl(attributes) {
     if (!attributes) {
         return "";
     }
-    const httpMethod = attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
+    const httpMethod = attributes[semanticConventions.SEMATTRS_HTTP_METHOD];
     if (httpMethod) {
-        const httpUrl = attributes[semanticConventions.SemanticAttributes.HTTP_URL];
+        const httpUrl = attributes[semanticConventions.SEMATTRS_HTTP_URL];
         if (httpUrl) {
             return String(httpUrl);
         }
         else {
-            const httpScheme = attributes[semanticConventions.SemanticAttributes.HTTP_SCHEME];
-            const httpTarget = attributes[semanticConventions.SemanticAttributes.HTTP_TARGET];
+            const httpScheme = attributes[semanticConventions.SEMATTRS_HTTP_SCHEME];
+            const httpTarget = attributes[semanticConventions.SEMATTRS_HTTP_TARGET];
             if (httpScheme && httpTarget) {
-                const httpHost = attributes[semanticConventions.SemanticAttributes.HTTP_HOST];
+                const httpHost = attributes[semanticConventions.SEMATTRS_HTTP_HOST];
                 if (httpHost) {
                     return `${httpScheme}://${httpHost}${httpTarget}`;
                 }
                 else {
-                    const netPeerPort = attributes[semanticConventions.SemanticAttributes.NET_PEER_PORT];
+                    const netPeerPort = attributes[semanticConventions.SEMATTRS_NET_PEER_PORT];
                     if (netPeerPort) {
-                        const netPeerName = attributes[semanticConventions.SemanticAttributes.NET_PEER_NAME];
+                        const netPeerName = attributes[semanticConventions.SEMATTRS_NET_PEER_NAME];
                         if (netPeerName) {
                             return `${httpScheme}://${netPeerName}:${netPeerPort}${httpTarget}`;
                         }
                         else {
-                            const netPeerIp = attributes[semanticConventions.SemanticAttributes.NET_PEER_IP];
+                            const netPeerIp = attributes[semanticConventions.SEMATTRS_NET_PEER_IP];
                             if (netPeerIp) {
                                 return `${httpScheme}://${netPeerIp}:${netPeerPort}${httpTarget}`;
                             }
@@ -2995,11 +3043,11 @@ function getDependencyTarget(attributes) {
     if (!attributes) {
         return "";
     }
-    const peerService = attributes[semanticConventions.SemanticAttributes.PEER_SERVICE];
-    const httpHost = attributes[semanticConventions.SemanticAttributes.HTTP_HOST];
-    const httpUrl = attributes[semanticConventions.SemanticAttributes.HTTP_URL];
-    const netPeerName = attributes[semanticConventions.SemanticAttributes.NET_PEER_NAME];
-    const netPeerIp = attributes[semanticConventions.SemanticAttributes.NET_PEER_IP];
+    const peerService = attributes[semanticConventions.SEMATTRS_PEER_SERVICE];
+    const httpHost = attributes[semanticConventions.SEMATTRS_HTTP_HOST];
+    const httpUrl = attributes[semanticConventions.SEMATTRS_HTTP_URL];
+    const netPeerName = attributes[semanticConventions.SEMATTRS_NET_PEER_NAME];
+    const netPeerIp = attributes[semanticConventions.SEMATTRS_NET_PEER_IP];
     if (peerService) {
         return String(peerService);
     }
@@ -3024,9 +3072,9 @@ function createResourceMetricEnvelope(resource, instrumentationKey) {
         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)) {
+                key === semanticConventions.SEMRESATTRS_TELEMETRY_SDK_VERSION ||
+                key === semanticConventions.SEMRESATTRS_TELEMETRY_SDK_LANGUAGE ||
+                key === semanticConventions.SEMRESATTRS_TELEMETRY_SDK_NAME)) {
                 resourceAttributes[key] = resource.attributes[key];
             }
         }
@@ -3099,7 +3147,7 @@ const getTimeSinceEnqueued = (span) => {
  */
 const parseEventHubSpan = (span, baseData) => {
     const namespace = span.attributes[AzNamespace];
-    const peerAddress = (span.attributes[semanticConventions.SemanticAttributes.NET_PEER_NAME] ||
+    const peerAddress = (span.attributes[semanticConventions.SEMATTRS_NET_PEER_NAME] ||
         span.attributes["peer.address"] ||
         "unknown").replace(/\/$/g, ""); // remove trailing "/"
     const messageBusDestination = (span.attributes[MessageBusDestination] || "unknown");
@@ -3128,18 +3176,22 @@ function createTagsFromSpan(span) {
     if (span.parentSpanId) {
         tags[KnownContextTagKeys.AiOperationParentId] = span.parentSpanId;
     }
-    const httpUserAgent = span.attributes[semanticConventions.SemanticAttributes.HTTP_USER_AGENT];
+    const endUserId = span.attributes[semanticConventions.SEMATTRS_ENDUSER_ID];
+    if (endUserId) {
+        tags[KnownContextTagKeys.AiUserId] = String(endUserId);
+    }
+    const httpUserAgent = span.attributes[semanticConventions.SEMATTRS_HTTP_USER_AGENT];
     if (httpUserAgent) {
         // TODO: Not exposed in Swagger, need to update def
         tags["ai.user.userAgent"] = String(httpUserAgent);
     }
     if (span.kind === api.SpanKind.SERVER) {
-        const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
-        const httpClientIp = span.attributes[semanticConventions.SemanticAttributes.HTTP_CLIENT_IP];
-        const netPeerIp = span.attributes[semanticConventions.SemanticAttributes.NET_PEER_IP];
+        const httpMethod = span.attributes[semanticConventions.SEMATTRS_HTTP_METHOD];
+        const httpClientIp = span.attributes[semanticConventions.SEMATTRS_HTTP_CLIENT_IP];
+        const netPeerIp = span.attributes[semanticConventions.SEMATTRS_NET_PEER_IP];
         if (httpMethod) {
-            const httpRoute = span.attributes[semanticConventions.SemanticAttributes.HTTP_ROUTE];
-            const httpUrl = span.attributes[semanticConventions.SemanticAttributes.HTTP_URL];
+            const httpRoute = span.attributes[semanticConventions.SEMATTRS_HTTP_ROUTE];
+            const httpUrl = span.attributes[semanticConventions.SEMATTRS_HTTP_URL];
             tags[KnownContextTagKeys.AiOperationName] = span.name; // Default
             if (httpRoute) {
                 tags[KnownContextTagKeys.AiOperationName] = `${httpMethod} ${httpRoute}`;
@@ -3174,21 +3226,24 @@ function createPropertiesFromSpanAttributes(attributes) {
         for (const key of Object.keys(attributes)) {
             // 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)) {
+                key === semanticConventions.SEMATTRS_NET_PEER_IP ||
+                key === semanticConventions.SEMATTRS_NET_PEER_NAME ||
+                key === semanticConventions.SEMATTRS_PEER_SERVICE ||
+                key === semanticConventions.SEMATTRS_HTTP_METHOD ||
+                key === semanticConventions.SEMATTRS_HTTP_URL ||
+                key === semanticConventions.SEMATTRS_HTTP_STATUS_CODE ||
+                key === semanticConventions.SEMATTRS_HTTP_ROUTE ||
+                key === semanticConventions.SEMATTRS_HTTP_HOST ||
+                key === semanticConventions.SEMATTRS_HTTP_URL ||
+                key === semanticConventions.SEMATTRS_DB_SYSTEM ||
+                key === semanticConventions.SEMATTRS_DB_STATEMENT ||
+                key === semanticConventions.SEMATTRS_DB_OPERATION ||
+                key === semanticConventions.SEMATTRS_DB_NAME ||
+                key === semanticConventions.SEMATTRS_RPC_SYSTEM ||
+                key === semanticConventions.SEMATTRS_RPC_GRPC_STATUS_CODE ||
+                key === semanticConventions.SEMATTRS_EXCEPTION_TYPE ||
+                key === semanticConventions.SEMATTRS_EXCEPTION_MESSAGE ||
+                key === semanticConventions.SEMATTRS_EXCEPTION_STACKTRACE)) {
                 properties[key] = attributes[key];
             }
         }
@@ -3224,12 +3279,12 @@ function createDependencyData(span) {
     if (span.kind === api.SpanKind.INTERNAL && span.parentSpanId) {
         remoteDependencyData.type = DependencyTypes.InProc;
     }
-    const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
-    const dbSystem = span.attributes[semanticConventions.SemanticAttributes.DB_SYSTEM];
-    const rpcSystem = span.attributes[semanticConventions.SemanticAttributes.RPC_SYSTEM];
+    const httpMethod = span.attributes[semanticConventions.SEMATTRS_HTTP_METHOD];
+    const dbSystem = span.attributes[semanticConventions.SEMATTRS_DB_SYSTEM];
+    const rpcSystem = span.attributes[semanticConventions.SEMATTRS_RPC_SYSTEM];
     // HTTP Dependency
     if (httpMethod) {
-        const httpUrl = span.attributes[semanticConventions.SemanticAttributes.HTTP_URL];
+        const httpUrl = span.attributes[semanticConventions.SEMATTRS_HTTP_URL];
         if (httpUrl) {
             try {
                 const dependencyUrl = new url.URL(String(httpUrl));
@@ -3239,7 +3294,7 @@ function createDependencyData(span) {
         }
         remoteDependencyData.type = DependencyTypes.Http;
         remoteDependencyData.data = getUrl(span.attributes);
-        const httpStatusCode = span.attributes[semanticConventions.SemanticAttributes.HTTP_STATUS_CODE];
+        const httpStatusCode = span.attributes[semanticConventions.SEMATTRS_HTTP_STATUS_CODE];
         if (httpStatusCode) {
             remoteDependencyData.resultCode = String(httpStatusCode);
         }
@@ -3266,16 +3321,16 @@ function createDependencyData(span) {
     // DB Dependency
     else if (dbSystem) {
         // TODO: Remove special logic when Azure UX supports OpenTelemetry dbSystem
-        if (String(dbSystem) === semanticConventions.DbSystemValues.MYSQL) {
+        if (String(dbSystem) === semanticConventions.DBSYSTEMVALUES_MYSQL) {
             remoteDependencyData.type = "mysql";
         }
-        else if (String(dbSystem) === semanticConventions.DbSystemValues.POSTGRESQL) {
+        else if (String(dbSystem) === semanticConventions.DBSYSTEMVALUES_POSTGRESQL) {
             remoteDependencyData.type = "postgresql";
         }
-        else if (String(dbSystem) === semanticConventions.DbSystemValues.MONGODB) {
+        else if (String(dbSystem) === semanticConventions.DBSYSTEMVALUES_MONGODB) {
             remoteDependencyData.type = "mongodb";
         }
-        else if (String(dbSystem) === semanticConventions.DbSystemValues.REDIS) {
+        else if (String(dbSystem) === semanticConventions.DBSYSTEMVALUES_REDIS) {
             remoteDependencyData.type = "redis";
         }
         else if (isSqlDB(String(dbSystem))) {
@@ -3284,8 +3339,8 @@ function createDependencyData(span) {
         else {
             remoteDependencyData.type = String(dbSystem);
         }
-        const dbStatement = span.attributes[semanticConventions.SemanticAttributes.DB_STATEMENT];
-        const dbOperation = span.attributes[semanticConventions.SemanticAttributes.DB_OPERATION];
+        const dbStatement = span.attributes[semanticConventions.SEMATTRS_DB_STATEMENT];
+        const dbOperation = span.attributes[semanticConventions.SEMATTRS_DB_OPERATION];
         if (dbStatement) {
             remoteDependencyData.data = String(dbStatement);
         }
@@ -3293,7 +3348,7 @@ function createDependencyData(span) {
             remoteDependencyData.data = String(dbOperation);
         }
         const target = getDependencyTarget(span.attributes);
-        const dbName = span.attributes[semanticConventions.SemanticAttributes.DB_NAME];
+        const dbName = span.attributes[semanticConventions.SEMATTRS_DB_NAME];
         if (target) {
             remoteDependencyData.target = dbName ? `${target}|${dbName}` : `${target}`;
         }
@@ -3309,7 +3364,7 @@ function createDependencyData(span) {
         else {
             remoteDependencyData.type = DependencyTypes.Grpc;
         }
-        const grpcStatusCode = span.attributes[semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE];
+        const grpcStatusCode = span.attributes[semanticConventions.SEMATTRS_RPC_GRPC_STATUS_CODE];
         if (grpcStatusCode) {
             remoteDependencyData.resultCode = String(grpcStatusCode);
         }
@@ -3332,11 +3387,11 @@ function createRequestData(span) {
         version: 2,
         source: undefined,
     };
-    const httpMethod = span.attributes[semanticConventions.SemanticAttributes.HTTP_METHOD];
-    const grpcStatusCode = span.attributes[semanticConventions.SemanticAttributes.RPC_GRPC_STATUS_CODE];
+    const httpMethod = span.attributes[semanticConventions.SEMATTRS_HTTP_METHOD];
+    const grpcStatusCode = span.attributes[semanticConventions.SEMATTRS_RPC_GRPC_STATUS_CODE];
     if (httpMethod) {
         requestData.url = getUrl(span.attributes);
-        const httpStatusCode = span.attributes[semanticConventions.SemanticAttributes.HTTP_STATUS_CODE];
+        const httpStatusCode = span.attributes[semanticConventions.SEMATTRS_HTTP_STATUS_CODE];
         if (httpStatusCode) {
             requestData.responseCode = String(httpStatusCode);
         }
@@ -3434,18 +3489,18 @@ function spanEventsToEnvelopes(span, ikey) {
                 let stack = "";
                 let hasFullStack = false;
                 if (event.attributes) {
-                    typeName = String(event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_TYPE]);
-                    stack = String(event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE]);
+                    typeName = String(event.attributes[semanticConventions.SEMATTRS_EXCEPTION_TYPE]);
+                    stack = String(event.attributes[semanticConventions.SEMATTRS_EXCEPTION_STACKTRACE]);
                     if (stack) {
                         hasFullStack = true;
                     }
-                    const exceptionMsg = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
+                    const exceptionMsg = event.attributes[semanticConventions.SEMATTRS_EXCEPTION_MESSAGE];
                     if (exceptionMsg) {
                         message = String(exceptionMsg);
                     }
-                    const escaped = event.attributes[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED];
+                    const escaped = event.attributes[semanticConventions.SEMATTRS_EXCEPTION_ESCAPED];
                     if (escaped !== undefined) {
-                        properties[semanticConventions.SemanticAttributes.EXCEPTION_ESCAPED] = String(escaped);
+                        properties[semanticConventions.SEMATTRS_EXCEPTION_ESCAPED] = String(escaped);
                     }
                 }
                 const exceptionDetails = {
@@ -3638,16 +3693,16 @@ function logToEnvelope(log, ikey) {
     const sampleRate = 100;
     const instrumentationKey = ikey;
     const tags = createTagsFromLog(log);
-    const [properties, measurements] = createPropertiesFromLog(log);
+    let [properties, measurements] = createPropertiesFromLog(log);
     let name;
     let baseType;
     let baseData;
     if (!log.attributes[ApplicationInsightsBaseType]) {
         // Get Exception attributes if available
-        const exceptionType = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_TYPE];
+        const exceptionType = log.attributes[semanticConventions.SEMATTRS_EXCEPTION_TYPE];
         if (exceptionType) {
-            const exceptionMessage = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_MESSAGE];
-            const exceptionStacktrace = log.attributes[semanticConventions.SemanticAttributes.EXCEPTION_STACKTRACE];
+            const exceptionMessage = log.attributes[semanticConventions.SEMATTRS_EXCEPTION_MESSAGE];
+            const exceptionStacktrace = log.attributes[semanticConventions.SEMATTRS_EXCEPTION_STACKTRACE];
             name = ApplicationInsightsExceptionName;
             baseType = ApplicationInsightsExceptionBaseType;
             const exceptionDetails = {
@@ -3679,6 +3734,7 @@ function logToEnvelope(log, ikey) {
         baseType = String(log.attributes[ApplicationInsightsBaseType]);
         name = getLegacyApplicationInsightsName(log);
         baseData = getLegacyApplicationInsightsBaseData(log);
+        measurements = getLegacyApplicationInsightsMeasurements(log);
         if (!baseData) {
             // Failed to parse log
             return;
@@ -3716,9 +3772,9 @@ function createPropertiesFromLog(log) {
         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)) {
+                key === semanticConventions.SEMATTRS_EXCEPTION_TYPE ||
+                key === semanticConventions.SEMATTRS_EXCEPTION_MESSAGE ||
+                key === semanticConventions.SEMATTRS_EXCEPTION_STACKTRACE)) {
                 properties[key] = log.attributes[key];
             }
         }
@@ -3767,6 +3823,14 @@ function getLegacyApplicationInsightsName(log) {
     }
     return name;
 }
+function getLegacyApplicationInsightsMeasurements(log) {
+    var _a;
+    let measurements = {};
+    if ((_a = log.body) === null || _a === void 0 ? void 0 : _a.measurements) {
+        measurements = Object.assign({}, log.body.measurements);
+    }
+    return measurements;
+}
 function getLegacyApplicationInsightsBaseData(log) {
     let baseData = {
         version: 2,
@@ -3775,19 +3839,19 @@ function getLegacyApplicationInsightsBaseData(log) {
         try {
             switch (log.attributes[ApplicationInsightsBaseType]) {
                 case ApplicationInsightsAvailabilityBaseType:
-                    baseData = JSON.parse(log.body);
+                    baseData = log.body;
                     break;
                 case ApplicationInsightsExceptionBaseType:
-                    baseData = JSON.parse(log.body);
+                    baseData = log.body;
                     break;
                 case ApplicationInsightsMessageBaseType:
-                    baseData = JSON.parse(log.body);
+                    baseData = log.body;
                     break;
                 case ApplicationInsightsPageViewBaseType:
-                    baseData = JSON.parse(log.body);
+                    baseData = log.body;
                     break;
                 case ApplicationInsightsEventBaseType:
-                    baseData = JSON.parse(log.body);
+                    baseData = log.body;
                     break;
             }
             if (typeof (baseData === null || baseData === void 0 ? void 0 : baseData.message) === "object") {

package/dist-esm/src/export/statsbeat/longIntervalStatsbeatMetrics.js

@@ -15,7 +15,6 @@ let instance = null;
 class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
     constructor(options) {
         super();
-        this.AZURE_MONITOR_STATSBEAT_FEATURES = process.env.AZURE_MONITOR_STATSBEAT_FEATURES;
         this.statsCollectionLongInterval = 86400000; // 1 day
         this.attach = "Manual";
         this.feature = 0;
@@ -25,15 +24,7 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
         const exporterConfig = {
             connectionString: this.connectionString,
         };
-        if (this.AZURE_MONITOR_STATSBEAT_FEATURES) {
-            try {
-                this.feature = JSON.parse(this.AZURE_MONITOR_STATSBEAT_FEATURES).feature;
-                this.instrumentation = JSON.parse(this.AZURE_MONITOR_STATSBEAT_FEATURES).instrumentation;
-            }
-            catch (error) {
-                diag.error(`LongIntervalStatsbeat: Failed to parse features/instrumentations (error ${error})`);
-            }
-        }
+        this.setFeatures();
         this.longIntervalStatsbeatMeterProvider = new MeterProvider();
         this.longIntervalAzureExporter = new AzureMonitorStatsbeatExporter(exporterConfig);
         // Export Long Interval Statsbeats every day
@@ -71,9 +62,7 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
             await this.getResourceProvider();
             // Add long interval observable callbacks
             this.attachStatsbeatGauge.addCallback(this.attachCallback.bind(this));
-            this.longIntervalStatsbeatMeter.addBatchObservableCallback(this.featureCallback.bind(this), [
-                this.featureStatsbeatGauge,
-            ]);
+            this.longIntervalStatsbeatMeter.addBatchObservableCallback(this.getEnvironmentStatus.bind(this), [this.featureStatsbeatGauge]);
             // Export Feature/Attach Statsbeat once upon app initialization
             this.longIntervalAzureExporter.export((await this.longIntervalMetricReader.collect()).resourceMetrics, (result) => {
                 if (result.code !== ExportResultCode.SUCCESS) {
@@ -85,7 +74,8 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
             diag.debug("Call to get the resource provider failed.");
         }
     }
-    featureCallback(observableResult) {
+    getEnvironmentStatus(observableResult) {
+        this.setFeatures();
         let attributes;
         if (this.instrumentation) {
             attributes = Object.assign(Object.assign({}, this.commonProperties), { feature: this.instrumentation, type: StatsbeatFeatureType.INSTRUMENTATION });
@@ -96,6 +86,18 @@ class LongIntervalStatsbeatMetrics extends StatsbeatMetrics {
             observableResult.observe(this.featureStatsbeatGauge, 1, Object.assign({}, attributes));
         }
     }
+    setFeatures() {
+        let statsbeatFeatures = process.env.AZURE_MONITOR_STATSBEAT_FEATURES;
+        if (statsbeatFeatures) {
+            try {
+                this.feature = JSON.parse(statsbeatFeatures).feature;
+                this.instrumentation = JSON.parse(statsbeatFeatures).instrumentation;
+            }
+            catch (error) {
+                diag.error(`LongIntervalStatsbeat: Failed to parse features/instrumentations (error ${error})`);
+            }
+        }
+    }
     attachCallback(observableResult) {
         const attributes = Object.assign(Object.assign({}, this.commonProperties), this.attachProperties);
         observableResult.observe(1, attributes);