Merge branch 'zhiyuanliang/startup-timeout' of https://github.com/Azure/AppConfiguration-JavaScriptProvider into zhiyuanliang/secret-refresh

Author: zhiyuanliang-ms

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure/app-configuration-provider",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "The JavaScript configuration provider for Azure App Configuration",
   "main": "dist/index.js",
   "module": "./dist-esm/index.js",

package.json

@@ -19,19 +19,20 @@ import {
     ENABLED_KEY_NAME,
     METADATA_KEY_NAME,
     ETAG_KEY_NAME,
-    FEATURE_FLAG_ID_KEY_NAME,
     FEATURE_FLAG_REFERENCE_KEY_NAME,
     ALLOCATION_KEY_NAME,
     SEED_KEY_NAME,
     VARIANTS_KEY_NAME,
     CONDITIONS_KEY_NAME,
     CLIENT_FILTERS_KEY_NAME
 } from "./featureManagement/constants.js";
-import { FM_PACKAGE_NAME } from "./requestTracing/constants.js";
+import { FM_PACKAGE_NAME, AI_MIME_PROFILE, AI_CHAT_COMPLETION_MIME_PROFILE } from "./requestTracing/constants.js";
+import { parseContentType, isJsonContentType, isFeatureFlagContentType, isSecretReferenceContentType } from "./common/contentType.js";
 import { AzureKeyVaultKeyValueAdapter } from "./keyvault/AzureKeyVaultKeyValueAdapter.js";
 import { RefreshTimer } from "./refresh/RefreshTimer.js";
 import { RequestTracingOptions, getConfigurationSettingWithTrace, listConfigurationSettingsWithTrace, requestTracingEnabled } from "./requestTracing/utils.js";
 import { FeatureFlagTracingOptions } from "./requestTracing/FeatureFlagTracingOptions.js";
+import { AIConfigurationTracingOptions } from "./requestTracing/AIConfigurationTracingOptions.js";
 import { KeyFilter, LabelFilter, SettingSelector } from "./types.js";
 import { ConfigurationClientManager } from "./ConfigurationClientManager.js";
 import { getFixedBackoffDuration, calculateBackoffDuration } from "./failover.js";
@@ -65,6 +66,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
     #isFailoverRequest: boolean = false;
     #featureFlagTracing: FeatureFlagTracingOptions | undefined;
     #fmVersion: string | undefined;
+    #aiConfigurationTracing: AIConfigurationTracingOptions | undefined;
 
     // Refresh
     #refreshInProgress: boolean = false;
@@ -111,6 +113,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         // enable request tracing if not opt-out
         this.#requestTracingEnabled = requestTracingEnabled();
         if (this.#requestTracingEnabled) {
+            this.#aiConfigurationTracing = new AIConfigurationTracingOptions();
             this.#featureFlagTracing = new FeatureFlagTracingOptions();
         }
 
@@ -191,7 +194,8 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
             replicaCount: this.#clientManager.getReplicaCount(),
             isFailoverRequest: this.#isFailoverRequest,
             featureFlagTracing: this.#featureFlagTracing,
-            fmVersion: this.#fmVersion
+            fmVersion: this.#fmVersion,
+            aiConfigurationTracing: this.#aiConfigurationTracing
         };
     }
 
@@ -489,19 +493,24 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
      * Loads selected key-values and watched settings (sentinels) for refresh from App Configuration to the local configuration.
      */
     async #loadSelectedAndWatchedKeyValues() {
+        this.#secretReferences = []; // clear all cached key vault reference configuration settings
         const keyValues: [key: string, value: unknown][] = [];
         const loadedSettings = await this.#loadConfigurationSettings();
         if (this.#refreshEnabled && !this.#watchAll) {
             await this.#updateWatchedKeyValuesEtag(loadedSettings);
         }
 
-        // clear all cached key vault reference configuration settings
-        this.#secretReferences = [];
+        if (this.#requestTracingEnabled && this.#aiConfigurationTracing !== undefined) {
+            // reset old AI configuration tracing in order to track the information present in the current response from server
+            this.#aiConfigurationTracing.reset();
+        }
+
+        // adapt configuration settings to key-values
         for (const setting of loadedSettings) {
             if (this.#secretRefreshEnabled && isSecretReference(setting)) {
                 this.#secretReferences.push(setting);
             }
-            const [key, value] = await this.#processKeyValues(setting);
+            const [key, value] = await this.#processKeyValue(setting);
             keyValues.push([key, value]);
         }
 
@@ -550,6 +559,11 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         const loadFeatureFlag = true;
         const featureFlagSettings = await this.#loadConfigurationSettings(loadFeatureFlag);
 
+        if (this.#requestTracingEnabled && this.#featureFlagTracing !== undefined) {
+            // Reset old feature flag tracing in order to track the information present in the current response from server.
+            this.#featureFlagTracing.reset();
+        }
+
         // parse feature flags
         const featureFlags = await Promise.all(
             featureFlagSettings.map(setting => this.#parseFeatureFlag(setting))
@@ -625,7 +639,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         }
 
         for (const setting of this.#secretReferences) {
-            const [key, value] = await this.#processKeyValues(setting);
+            const [key, value] = await this.#processKeyValue(setting);
             this.#configMap.set(key, value);
         }
 
@@ -735,12 +749,35 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         throw new Error("All fallback clients failed to get configuration settings.");
     }
 
-    async #processKeyValues(setting: ConfigurationSetting<string>): Promise<[string, unknown]> {
+    async #processKeyValue(setting: ConfigurationSetting<string>): Promise<[string, unknown]> {
+        this.#setAIConfigurationTracing(setting);
+
         const [key, value] = await this.#processAdapters(setting);
         const trimmedKey = this.#keyWithPrefixesTrimmed(key);
         return [trimmedKey, value];
     }
 
+    #setAIConfigurationTracing(setting: ConfigurationSetting<string>): void {
+        if (this.#requestTracingEnabled && this.#aiConfigurationTracing !== undefined) {
+            const contentType = parseContentType(setting.contentType);
+            // content type: "application/json; profile=\"https://azconfig.io/mime-profiles/ai\"""
+            if (isJsonContentType(contentType) &&
+                !isFeatureFlagContentType(contentType) &&
+                !isSecretReferenceContentType(contentType)) {
+                const profile = contentType?.parameters["profile"];
+                if (profile === undefined) {
+                    return;
+                }
+                if (profile.includes(AI_MIME_PROFILE)) {
+                    this.#aiConfigurationTracing.usesAIConfiguration = true;
+                }
+                if (profile.includes(AI_CHAT_COMPLETION_MIME_PROFILE)) {
+                    this.#aiConfigurationTracing.usesAIChatCompletionConfiguration = true;
+                }
+            }
+        }
+    }
+
     async #processAdapters(setting: ConfigurationSetting<string>): Promise<[string, unknown]> {
         for (const adapter of this.#adapters) {
             if (adapter.canProcess(setting)) {
@@ -772,12 +809,25 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
             const metadata = featureFlag[TELEMETRY_KEY_NAME][METADATA_KEY_NAME];
             featureFlag[TELEMETRY_KEY_NAME][METADATA_KEY_NAME] = {
                 [ETAG_KEY_NAME]: setting.etag,
-                [FEATURE_FLAG_ID_KEY_NAME]: await this.#calculateFeatureFlagId(setting),
                 [FEATURE_FLAG_REFERENCE_KEY_NAME]: this.#createFeatureFlagReference(setting),
                 ...(metadata || {})
             };
         }
 
+        this.#setFeatureFlagTracing(featureFlag);
+
+        return featureFlag;
+    }
+
+    #createFeatureFlagReference(setting: ConfigurationSetting<string>): string {
+        let featureFlagReference = `${this.#clientManager.endpoint.origin}/kv/${setting.key}`;
+        if (setting.label && setting.label.trim().length !== 0) {
+            featureFlagReference += `?label=${setting.label}`;
+        }
+        return featureFlagReference;
+    }
+
+    #setFeatureFlagTracing(featureFlag: any): void {
         if (this.#requestTracingEnabled && this.#featureFlagTracing !== undefined) {
             if (featureFlag[CONDITIONS_KEY_NAME] &&
                 featureFlag[CONDITIONS_KEY_NAME][CLIENT_FILTERS_KEY_NAME] &&
@@ -796,66 +846,6 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
                 this.#featureFlagTracing.usesSeed = true;
             }
         }
-
-        return featureFlag;
-    }
-
-    async #calculateFeatureFlagId(setting: ConfigurationSetting<string>): Promise<string> {
-        let crypto;
-
-        // Check for browser environment
-        if (typeof window !== "undefined" && window.crypto && window.crypto.subtle) {
-            crypto = window.crypto;
-        }
-        // Check for Node.js environment
-        else if (typeof global !== "undefined" && global.crypto) {
-            crypto = global.crypto;
-        }
-        // Fallback to native Node.js crypto module
-        else {
-            try {
-                if (typeof module !== "undefined" && module.exports) {
-                    crypto = require("crypto");
-                }
-                else {
-                    crypto = await import("crypto");
-                }
-            } catch (error) {
-                console.error("Failed to load the crypto module:", error.message);
-                throw error;
-            }
-        }
-
-        let baseString = `${setting.key}\n`;
-        if (setting.label && setting.label.trim().length !== 0) {
-            baseString += `${setting.label}`;
-        }
-
-        // Convert to UTF-8 encoded bytes
-        const data = new TextEncoder().encode(baseString);
-
-        // In the browser, use crypto.subtle.digest
-        if (crypto.subtle) {
-            const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-            const hashArray = new Uint8Array(hashBuffer);
-            // btoa/atob is also available in Node.js 18+
-            const base64String = btoa(String.fromCharCode(...hashArray));
-            const base64urlString = base64String.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-            return base64urlString;
-        }
-        // In Node.js, use the crypto module's hash function
-        else {
-            const hash = crypto.createHash("sha256").update(data).digest();
-            return hash.toString("base64url");
-        }
-    }
-
-    #createFeatureFlagReference(setting: ConfigurationSetting<string>): string {
-        let featureFlagReference = `${this.#clientManager.endpoint.origin}/kv/${setting.key}`;
-        if (setting.label && setting.label.trim().length !== 0) {
-            featureFlagReference += `?label=${setting.label}`;
-        }
-        return featureFlagReference;
     }
 }
 

src/AzureAppConfigurationImpl.ts

@@ -28,14 +28,15 @@ const DNS_RESOLVER_TRIES = 2;
 const MAX_ALTNATIVE_SRV_COUNT = 10;
 
 export class ConfigurationClientManager {
+    readonly endpoint: URL; // primary endpoint, which is the one specified in the connection string or passed in as a parameter
     #isFailoverable: boolean;
     #dns: any;
     #secret : string;
     #id : string;
     #credential: TokenCredential;
     #clientOptions: AppConfigurationClientOptions | undefined;
     #appConfigOptions: AzureAppConfigurationOptions | undefined;
-    #validDomain: string;
+    #validDomain: string; // valid domain for the primary endpoint, which is used to discover replicas
     #staticClients: ConfigurationClientWrapper[]; // there should always be only one static client
     #dynamicClients: ConfigurationClientWrapper[];
     #replicaCount: number = 0;

src/ConfigurationClientManager.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 import { ConfigurationSetting, featureFlagContentType, secretReferenceContentType } from "@azure/app-configuration";
+import { parseContentType, isJsonContentType } from "./common/contentType.js";
 import { IKeyValueAdapter } from "./IKeyValueAdapter.js";
 
 export class JsonKeyValueAdapter implements IKeyValueAdapter {
@@ -17,7 +18,8 @@ export class JsonKeyValueAdapter implements IKeyValueAdapter {
         if (JsonKeyValueAdapter.#ExcludedJsonContentTypes.includes(setting.contentType)) {
             return false;
         }
-        return isJsonContentType(setting.contentType);
+        const contentType = parseContentType(setting.contentType);
+        return isJsonContentType(contentType);
     }
 
     async processKeyValue(setting: ConfigurationSetting): Promise<[string, unknown]> {
@@ -38,24 +40,3 @@ export class JsonKeyValueAdapter implements IKeyValueAdapter {
         return;
     }
 }
-
-// Determine whether a content type string is a valid JSON content type.
-// https://docs.microsoft.com/en-us/azure/azure-app-configuration/howto-leverage-json-content-type
-function isJsonContentType(contentTypeValue: string): boolean {
-    if (!contentTypeValue) {
-        return false;
-    }
-
-    const contentTypeNormalized: string = contentTypeValue.trim().toLowerCase();
-    const mimeType: string = contentTypeNormalized.split(";", 1)[0].trim();
-    const typeParts: string[] = mimeType.split("/");
-    if (typeParts.length !== 2) {
-        return false;
-    }
-
-    if (typeParts[0] !== "application") {
-        return false;
-    }
-
-    return typeParts[1].split("+").includes("json");
-}

src/JsonKeyValueAdapter.ts

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { secretReferenceContentType, featureFlagContentType } from "@azure/app-configuration";
+
+export type ContentType = {
+    mediaType: string;
+    parameters: Record<string, string>;
+}
+
+export function parseContentType(contentTypeValue: string | undefined): ContentType | undefined {
+    if (!contentTypeValue) {
+        return undefined;
+    }
+    const [mediaType, ...args] = contentTypeValue.split(";").map((s) => s.trim().toLowerCase());
+    const parameters: Record<string, string> = {};
+
+    for (const param of args) {
+        const [key, value] = param.split("=").map((s) => s.trim().toLowerCase());
+        if (key && value) {
+            parameters[key] = value;
+        }
+    }
+
+    return { mediaType, parameters };
+}
+
+// Determine whether a content type string is a valid JSON content type.
+// https://docs.microsoft.com/en-us/azure/azure-app-configuration/howto-leverage-json-content-type
+export function isJsonContentType(contentType: ContentType | undefined): boolean {
+    const mediaType = contentType?.mediaType;
+    if (!mediaType) {
+        return false;
+    }
+
+    const typeParts: string[] = mediaType.split("/");
+    if (typeParts.length !== 2) {
+        return false;
+    }
+
+    if (typeParts[0] !== "application") {
+        return false;
+    }
+
+    return typeParts[1].split("+").includes("json");
+}
+
+export function isFeatureFlagContentType(contentType: ContentType | undefined): boolean {
+    const mediaType = contentType?.mediaType;
+    if (!mediaType) {
+        return false;
+    }
+    return mediaType === featureFlagContentType;
+}
+
+export function isSecretReferenceContentType(contentType: ContentType | undefined): boolean {
+    const mediaType = contentType?.mediaType;
+    if (!mediaType) {
+        return false;
+    }
+    return mediaType === secretReferenceContentType;
+}

src/common/contentType.ts

@@ -8,7 +8,6 @@ export const TELEMETRY_KEY_NAME = "telemetry";
 export const ENABLED_KEY_NAME = "enabled";
 export const METADATA_KEY_NAME = "metadata";
 export const ETAG_KEY_NAME = "ETag";
-export const FEATURE_FLAG_ID_KEY_NAME = "FeatureFlagId";
 export const FEATURE_FLAG_REFERENCE_KEY_NAME = "FeatureFlagReference";
 export const ALLOCATION_KEY_NAME = "allocation";
 export const DEFAULT_WHEN_ENABLED_KEY_NAME = "default_when_enabled";

src/featureManagement/constants.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+export class AIConfigurationTracingOptions {
+    usesAIConfiguration: boolean = false;
+    usesAIChatCompletionConfiguration: boolean = false;
+
+    reset(): void {
+        this.usesAIConfiguration = false;
+        this.usesAIChatCompletionConfiguration = false;
+    }
+
+    usesAnyTracingFeature() {
+        return this.usesAIConfiguration || this.usesAIChatCompletionConfiguration;
+    }
+}