@fluidframework/container-loader 0.52.0 → 0.54.0-47413

package/src/loader.ts

@@ -25,7 +25,16 @@ import {
     IProxyLoaderFactory,
     LoaderHeader,
 } from "@fluidframework/container-definitions";
-import { ChildLogger, DebugLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
+import {
+    ChildLogger,
+    DebugLogger,
+    IConfigProviderBase,
+    loggerToMonitoringContext,
+    mixinMonitoringContext,
+    MonitoringContext,
+    PerformanceEvent,
+    sessionStorageConfigProvider,
+} from "@fluidframework/telemetry-utils";
 import {
     IDocumentServiceFactory,
     IDocumentStorageService,
@@ -41,6 +50,7 @@ import {
 } from "@fluidframework/driver-utils";
 import { Container } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
+import { pkgVersion } from "./packageVersion";
 
 function canUseCache(request: IRequest): boolean {
     if (request.headers === undefined) {
@@ -124,32 +134,37 @@ export interface ILoaderOptions extends ILoaderOptions1{
 }
 
 /**
+ * @deprecated IFluidModuleWithDetails interface is moved to
+ * {@link @fluidframework/container-definition#IFluidModuleWithDetails}
+ * to have all the code loading modules in one package. #8193
  * Encapsulates a module entry point with corresponding code details.
  */
- export interface IFluidModuleWithDetails {
-     /** Fluid code module that implements the runtime factory needed to instantiate the container runtime. */
-     module: IFluidModule;
-     /**
-      * Code details associated with the module. Represents a document schema this module supports.
-      * If the code loader implements the {@link @fluidframework/core-interfaces#IFluidCodeDetailsComparer} interface,
-      * it'll be called to determine whether the module code details satisfy the new code proposal in the quorum.
-      */
-     details: IFluidCodeDetails;
- }
+export interface IFluidModuleWithDetails {
+    /** Fluid code module that implements the runtime factory needed to instantiate the container runtime. */
+    module: IFluidModule;
+    /**
+     * Code details associated with the module. Represents a document schema this module supports.
+     * If the code loader implements the {@link @fluidframework/core-interfaces#IFluidCodeDetailsComparer} interface,
+     * it'll be called to determine whether the module code details satisfy the new code proposal in the quorum.
+     */
+    details: IFluidCodeDetails;
+}
 
 /**
+ * @deprecated ICodeDetailsLoader interface is moved to {@link @fluidframework/container-definition#ICodeDetailsLoader}
+ * to have code loading modules in one package. #8193
  * Fluid code loader resolves a code module matching the document schema, i.e. code details, such as
  * a package name and package version range.
  */
 export interface ICodeDetailsLoader
-    extends Partial<IProvideFluidCodeDetailsComparer> {
-    /**
-     * Load the code module (package) that is capable to interact with the document.
-     *
-     * @param source - Code proposal that articulates the current schema the document is written in.
-     * @returns - Code module entry point along with the code details associated with it.
-     */
-    load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
+ extends Partial<IProvideFluidCodeDetailsComparer> {
+ /**
+  * Load the code module (package) that is capable to interact with the document.
+  *
+  * @param source - Code proposal that articulates the current schema the document is written in.
+  * @returns - Code module entry point along with the code details associated with it.
+  */
+ load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
 }
 
 /**
@@ -201,6 +216,11 @@ export interface ILoaderProps {
      * Blobs storage for detached containers.
      */
     readonly detachedBlobStorage?: IDetachedBlobStorage;
+
+    /**
+     * The configuration provider which may be used to control features.
+     */
+     readonly configProvider?: IConfigProviderBase;
 }
 
 /**
@@ -272,29 +292,41 @@ export type IDetachedBlobStorage = Pick<IDocumentStorageService, "createBlob" |
 export class Loader implements IHostLoader {
     private readonly containers = new Map<string, Promise<Container>>();
     public readonly services: ILoaderServices;
-    private readonly logger: ITelemetryLogger;
+    private readonly mc: MonitoringContext;
 
     constructor(loaderProps: ILoaderProps) {
         const scope = { ...loaderProps.scope as FluidObject<ILoader> };
         if (loaderProps.options?.provideScopeLoader !== false) {
             scope.ILoader = this;
         }
+        const telemetryProps = {
+            loaderId: uuid(),
+            loaderVersion: pkgVersion,
+        };
+
+        const subMc = mixinMonitoringContext(
+            DebugLogger.mixinDebugLogger("fluid:telemetry", loaderProps.logger, { all: telemetryProps }),
+            sessionStorageConfigProvider.value,
+            loaderProps.configProvider,
+        );
+
         this.services = {
             urlResolver: createCachedResolver(MultiUrlResolver.create(loaderProps.urlResolver)),
             documentServiceFactory: MultiDocumentServiceFactory.create(loaderProps.documentServiceFactory),
             codeLoader: loaderProps.codeLoader,
             options: loaderProps.options ?? {},
             scope,
-            subLogger: DebugLogger.mixinDebugLogger("fluid:telemetry", loaderProps.logger, { all:{loaderId: uuid()} }),
+            subLogger: subMc.logger,
             proxyLoaderFactories: loaderProps.proxyLoaderFactories ?? new Map<string, IProxyLoaderFactory>(),
             detachedBlobStorage: loaderProps.detachedBlobStorage,
         };
-        this.logger = ChildLogger.create(this.services.subLogger, "Loader");
+        this.mc = loggerToMonitoringContext(
+            ChildLogger.create(this.services.subLogger, "Loader"));
     }
 
     public get IFluidRouter(): IFluidRouter { return this; }
 
-    public async createDetachedContainer(codeDetails: IFluidCodeDetails): Promise<Container> {
+    public async createDetachedContainer(codeDetails: IFluidCodeDetails): Promise<IContainer> {
         const container = await Container.createDetached(
             this,
             codeDetails,
@@ -313,13 +345,13 @@ export class Loader implements IHostLoader {
         return container;
     }
 
-    public async rehydrateDetachedContainerFromSnapshot(snapshot: string): Promise<Container> {
+    public async rehydrateDetachedContainerFromSnapshot(snapshot: string): Promise<IContainer> {
         return Container.rehydrateDetachedFromSnapshot(this, snapshot);
     }
 
-    public async resolve(request: IRequest, pendingLocalState?: string): Promise<Container> {
+    public async resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer> {
         const eventName = pendingLocalState === undefined ? "Resolve" : "ResolveWithPendingState";
-        return PerformanceEvent.timedExecAsync(this.logger, { eventName }, async () => {
+        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName }, async () => {
             const resolved = await this.resolveCore(
                 request,
                 pendingLocalState !== undefined ? JSON.parse(pendingLocalState) : undefined,
@@ -329,7 +361,7 @@ export class Loader implements IHostLoader {
     }
 
     public async request(request: IRequest): Promise<IResponse> {
-        return PerformanceEvent.timedExecAsync(this.logger, { eventName: "Request" }, async () => {
+        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => {
             const resolved = await this.resolveCore(request);
             return resolved.container.request({
                 ...request,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "0.52.0";
+export const pkgVersion = "0.54.0-47413";