@teambit/workspace 1.0.1018 → 1.0.1020

package/dist/workspace-component/workspace-component-loader.js

@@ -116,6 +116,13 @@ function _harmonyModules2() {
   };
   return data;
 }
+function _harmonyModules3() {
+  const data = require("@teambit/harmony.modules.load-trace");
+  _harmonyModules3 = function () {
+    return data;
+  };
+  return data;
+}
 function _workspaceComponent() {
   const data = require("./workspace-component");
   _workspaceComponent = function () {
@@ -177,9 +184,14 @@ class WorkspaceComponentLoader {
         invalidComponents: []
       };
     }
+    return (0, _harmonyModules3().startOrJoinLoadTrace)('workspace.getMany', {
+      ids: idsWithoutEmpty.length
+    }, span => this.getManyWithSpan(idsWithoutEmpty, span, loadOpts, throwOnFailure));
+  }
+  async getManyWithSpan(idsWithoutEmpty, span, loadOpts, throwOnFailure = true) {
     const callId = Math.floor(Math.random() * 1000); // generate a random callId to be able to identify the call from the logs
     this.logger.profileTrace(`getMany-${callId}`);
-    this.logger.setStatusLine(`loading ${ids.length} component(s)`);
+    this.logger.setStatusLine(`loading ${idsWithoutEmpty.length} component(s)`);
     const loadOptsWithDefaults = Object.assign(
     // We don't want to load extension or execute the load slot at this step
     // we will do it later
@@ -205,6 +217,8 @@ class WorkspaceComponentLoader {
         loadOrCached.idsToLoad.push(id);
       }
     }, loadOrCached);
+    span.setAttribute('componentsCache:hits', loadOrCached.fromCache.length);
+    span.setAttribute('componentsCache:misses', loadOrCached.idsToLoad.length);
     const {
       components: loadedComponents,
       invalidComponents
@@ -225,7 +239,7 @@ class WorkspaceComponentLoader {
         executeLoadSlot: true
       });
     });
-    const idsWithEmptyStrs = ids.map(id => id.toString());
+    const idsWithEmptyStrs = idsWithoutEmpty.map(id => id.toString());
     const requestedComponents = components.filter(comp => idsWithEmptyStrs.includes(comp.id.toString()) || idsWithEmptyStrs.includes(comp.id.toStringWithoutVersion()));
     this.logger.profileTrace(`getMany-${callId}`);
     this.logger.clearStatusLine();
@@ -239,9 +253,11 @@ class WorkspaceComponentLoader {
       components: [],
       invalidComponents: []
     };
-    const workspaceScopeIdsMap = await this.groupAndUpdateIds(ids);
+    const workspaceScopeIdsMap = await (0, _harmonyModules3().loadSpan)('id-resolution', {
+      ids: ids.length
+    }, () => this.groupAndUpdateIds(ids));
     this.logger.profileTrace('buildLoadGroups');
-    const groupsToHandle = await this.buildLoadGroups(workspaceScopeIdsMap);
+    const groupsToHandle = await (0, _harmonyModules3().loadSpan)('build-load-groups', {}, () => this.buildLoadGroups(workspaceScopeIdsMap));
     this.logger.profileTrace('buildLoadGroups');
     // prefix your command with "BIT_LOG=*" to see the detailed groups
     if (process.env.BIT_LOG) {
@@ -256,17 +272,21 @@ class WorkspaceComponentLoader {
         seeders,
         envs
       } = group;
-      const groupDesc = `getMany-${callId} group ${index + 1}/${groupsToHandle.length} - ${loadGroupToStr(group)}`;
+      const groupStr = loadGroupToStr(group);
+      const groupDesc = `getMany-${callId} group ${index + 1}/${groupsToHandle.length} - ${groupStr}`;
       this.logger.profileTrace(groupDesc);
       if (!workspaceIds.length && !scopeIds.length) {
         throw new Error('getAndLoadSlotOrdered - group has no ids to load');
       }
-      const res = await this.getAndLoadSlot(workspaceIds, scopeIds, _objectSpread(_objectSpread({}, loadOpts), {}, {
+      const res = await (0, _harmonyModules3().loadSpan)('load-group', {
+        group: `${index + 1}/${groupsToHandle.length}`,
+        desc: groupStr
+      }, () => this.getAndLoadSlot(workspaceIds, scopeIds, _objectSpread(_objectSpread({}, loadOpts), {}, {
         core,
         seeders,
         aspects,
         envs
-      }));
+      })));
       this.logger.profileTrace(groupDesc);
       // We don't want to return components that were not asked originally (we do want to load them)
       if (!group.seeders) return undefined;
@@ -485,7 +505,9 @@ class WorkspaceComponentLoader {
     });
     if (loadOpts.loadExtensions) {
       this.logger.profileTrace('loadComponentsExtensions');
-      await this.workspace.loadComponentsExtensions(filteredMergeExtensions);
+      await (0, _harmonyModules3().loadSpan)('load-components-extensions', {
+        extensions: filteredMergeExtensions.length
+      }, () => this.workspace.loadComponentsExtensions(filteredMergeExtensions));
       this.logger.profileTrace('loadComponentsExtensions');
     }
     let wsComponentsWithAspects = workspaceComponents;
@@ -505,16 +527,19 @@ class WorkspaceComponentLoader {
     // so we will get wrong dependencies from component who uses envs from the workspace
     this.logger.profileTrace('loadCompsAsAspects');
     if (loadOpts.loadSeedersAsAspects || loadOpts.core && loadOpts.aspects) {
-      await this.loadCompsAsAspects(workspaceComponents.concat(scopeComponents), {
+      await (0, _harmonyModules3().loadSpan)('load-comps-as-aspects', {
+        components: workspaceComponents.length + scopeComponents.length
+      }, () => this.loadCompsAsAspects(workspaceComponents.concat(scopeComponents), {
         loadApps: true,
         loadEnvs: true,
         loadAspects: loadOpts.aspects,
         core: loadOpts.core,
         seeders: loadOpts.seeders,
         idsToNotLoadAsAspects: loadOpts.idsToNotLoadAsAspects
-      });
+      }));
     }
     this.logger.profileTrace('loadCompsAsAspects');
+    this.attachReportedLoadFailures(withAspects);
     return {
       components: withAspects,
       invalidComponents
@@ -560,13 +585,80 @@ class WorkspaceComponentLoader {
       });
     } catch (err) {
       this.logger.warn(`failed loading components as aspects for components ${aspectIds.join(', ')}`, err);
-      // we ignore that errors at the moment
+      // the error is not thrown (best-effort loading), but it's surfaced as a component issue
+      // so it shows up in "bit status" instead of disappearing.
+      if (!this.workspace.inInstallContext) {
+        const errMsg = err.message || String(err);
+        aspectIds.forEach(aspectId => {
+          (0, _harmonyModules3().reportLoadFailure)({
+            failedId: aspectId,
+            phase: 'load-comps-as-aspects',
+            error: errMsg
+          });
+        });
+        components.forEach(component => {
+          if (!aspectIds.includes(component.id.toString())) return;
+          this.addLoadFailureIssue(component, component.id.toString(), 'load-comps-as-aspects', errMsg);
+        });
+      }
     }
   }
+  addLoadFailureIssue(component, failedId, phase, error) {
+    const consumerComponent = component.state._consumer;
+    if (!consumerComponent) return;
+    const issue = component.state.issues.getOrCreate(_componentIssues().IssuesClasses.LoadFailures);
+    const alreadyReported = issue.data.some(entry => entry.failedId === failedId && entry.phase === phase);
+    if (!alreadyReported) issue.data.push({
+      failedId,
+      phase,
+      error
+    });
+  }
+
+  /**
+   * surface load failures that were reported to the active trace by deep loader code (e.g. aspect
+   * require failures in the scope loader). the failing component itself gets a per-component
+   * issue. components merely *using* the failed aspect/env are aggregated into a single
+   * workspace-level issue — one failing env may be used by 100 components, and attaching the
+   * issue to each of them would flood "bit status".
+   */
+  attachReportedLoadFailures(components) {
+    if (this.workspace.inInstallContext) return;
+    const failures = (0, _harmonyModules3().currentLoadTrace)()?.loadFailures;
+    if (!failures?.length) return;
+    const noVersion = id => id.split('@')[0];
+    components.forEach(component => {
+      const componentIdStr = component.id.toString();
+      const usedIds = component.state._consumer ? component.state._consumer.extensions.map(ext => ext.stringId) : [];
+      // the env may be set via the EnvsAspect config rather than as a direct extension entry, in
+      // which case its id won't appear in the extensions list above. include it explicitly so a
+      // failure loading that env still gets aggregated to this component.
+      const envId = component.state.aspects.get(_envs().EnvsAspect.id)?.data?.id;
+      if (envId) usedIds.push(envId);
+      failures.forEach(failure => {
+        if (noVersion(failure.failedId) === noVersion(componentIdStr)) {
+          this.addLoadFailureIssue(component, failure.failedId, failure.phase, failure.error);
+          return;
+        }
+        if (usedIds.some(usedId => noVersion(usedId) === noVersion(failure.failedId))) {
+          this.workspace.registerAggregatedLoadFailure(failure, componentIdStr);
+        }
+      });
+    });
+  }
   async populateScopeAndExtensionsCache(ids, workspaceScopeIdsMap) {
-    return (0, _pMapSeries().default)(ids, async id => {
+    return (0, _harmonyModules3().loadSpan)('populate-scope-and-extensions-cache', {
+      ids: ids.length
+    }, span => this.populateScopeAndExtensionsCacheWithSpan(ids, workspaceScopeIdsMap, span));
+  }
+  async populateScopeAndExtensionsCacheWithSpan(ids, workspaceScopeIdsMap, span) {
+    let scopeCacheHits = 0;
+    let extensionsCacheHits = 0;
+    const result = await (0, _pMapSeries().default)(ids, async id => {
       const idStr = id.toString();
       let componentFromScope;
+      if (this.scopeComponentsCache.has(idStr)) scopeCacheHits += 1;
+      if (this.componentsExtensionsCache.has(idStr)) extensionsCacheHits += 1;
       if (!this.scopeComponentsCache.has(idStr)) {
         try {
           // Do not import automatically if it's missing, it will throw an error later
@@ -597,6 +689,10 @@ class WorkspaceComponentLoader {
         });
       }
     });
+    span.setAttribute('scopeComponentsCache:hits', scopeCacheHits);
+    span.setAttribute('scopeComponentsCache:misses', ids.length - scopeCacheHits);
+    span.setAttribute('componentsExtensionsCache:hits', extensionsCacheHits);
+    return result;
   }
   async warnAboutMisconfiguredEnvs(components) {
     const allIds = (0, _lodash().uniq)(components.map(component => this.envs.getEnvId(component)));
@@ -650,7 +746,9 @@ class WorkspaceComponentLoader {
       components: legacyComponents,
       invalidComponents: legacyInvalidComponents,
       removedComponents
-    } = await this.workspace.consumer.loadComponents(_componentId().ComponentIdList.fromArray(workspaceIds), false, loadOptsWithDefaults);
+    } = await (0, _harmonyModules3().loadSpan)('consumer-fs-load', {
+      ids: workspaceIds.length
+    }, () => this.workspace.consumer.loadComponents(_componentId().ComponentIdList.fromArray(workspaceIds), false, loadOptsWithDefaults));
     this.logger.profileTrace('consumer.loadComponents');
     const allLegacyComponents = legacyComponents.concat(removedComponents);
     legacyInvalidComponents.forEach(invalidComponent => {
@@ -712,7 +810,9 @@ class WorkspaceComponentLoader {
     // as when loading the next batch of components (next group) we won't have the envs loaded
 
     try {
-      const scopeComponents = await this.workspace.scope.getMany(scopeIds);
+      const scopeComponents = await (0, _harmonyModules3().loadSpan)('scope-load', {
+        ids: scopeIds.length
+      }, () => this.workspace.scope.getMany(scopeIds));
 
       // We don't want to load envs as part of this step, they will be loaded later
       // const scopeComponents = await this.workspace.scope.loadMany(scopeIds, undefined, {
@@ -754,6 +854,13 @@ class WorkspaceComponentLoader {
   }
   async get(componentId, legacyComponent, useCache = true, storeInCache = true, loadOpts, getOpts = {
     resolveIdVersion: true
+  }) {
+    return (0, _harmonyModules3().startOrJoinLoadTrace)('workspace.get', {
+      id: componentId.toString()
+    }, span => this.getWithSpan(componentId, span, legacyComponent, useCache, storeInCache, loadOpts, getOpts));
+  }
+  async getWithSpan(componentId, span, legacyComponent, useCache = true, storeInCache = true, loadOpts, getOpts = {
+    resolveIdVersion: true
   }) {
     const loadOptsWithDefaults = Object.assign({
       loadExtensions: true,
@@ -762,17 +869,22 @@ class WorkspaceComponentLoader {
     const id = getOpts?.resolveIdVersion ? this.resolveVersion(componentId) : componentId;
     const fromCache = this.getFromCache(id, loadOptsWithDefaults);
     if (fromCache && useCache) {
+      span.setAttribute('componentsCache', 'hit');
       return fromCache;
     }
+    span.setAttribute('componentsCache', 'miss');
     let consumerComponent = legacyComponent;
     const inWs = await this.isInWsIncludeDeleted(id);
     if (inWs && !consumerComponent) {
-      consumerComponent = await this.getConsumerComponent(id, loadOptsWithDefaults);
+      consumerComponent = await (0, _harmonyModules3().loadSpan)('consumer-fs-load', {
+        id: id.toString()
+      }, () => this.getConsumerComponent(id, loadOptsWithDefaults));
     }
 
     // in case of out-of-sync, the id may changed during the load process
     const updatedId = consumerComponent ? consumerComponent.id : id;
     const component = await this.loadOne(updatedId, consumerComponent, loadOptsWithDefaults);
+    this.attachReportedLoadFailures([component]);
     if (storeInCache) {
       this.addMultipleEnvsIssueIfNeeded(component); // it's in storeInCache block, otherwise, it wasn't fully loaded
       this.saveInCache(component, loadOptsWithDefaults);
@@ -821,7 +933,10 @@ class WorkspaceComponentLoader {
   }
   async loadOne(id, consumerComponent, loadOpts) {
     const idStr = id.toString();
-    const componentFromScope = this.scopeComponentsCache.has(idStr) ? this.scopeComponentsCache.get(idStr) : await this.workspace.scope.get(id);
+    const scopeCacheHit = this.scopeComponentsCache.has(idStr);
+    const componentFromScope = scopeCacheHit ? this.scopeComponentsCache.get(idStr) : await (0, _harmonyModules3().loadSpan)('scope-load', {
+      id: idStr
+    }, () => this.workspace.scope.get(id));
     if (!consumerComponent) {
       if (!componentFromScope) throw new (_legacy3().MissingBitMapComponent)(id.toString());
       return componentFromScope;
@@ -830,9 +945,13 @@ class WorkspaceComponentLoader {
     const {
       extensions,
       errors
-    } = extErrorsFromCache || (await this.workspace.componentExtensions(id, componentFromScope, undefined, {
+    } = extErrorsFromCache || (await (0, _harmonyModules3().loadSpan)('extension-merge', {
+      id: idStr,
+      scopeComponentsCache: scopeCacheHit ? 'hit' : 'miss',
+      componentsExtensionsCache: 'miss'
+    }, () => this.workspace.componentExtensions(id, componentFromScope, undefined, {
       loadExtensions: loadOpts?.loadExtensions
-    }));
+    })));
     if (errors?.some(err => err instanceof _mergeConfigConflict().MergeConfigConflict)) {
       consumerComponent.issues.getOrCreate(_componentIssues().IssuesClasses.MergeConfigHasConflict).data = true;
     }
@@ -911,6 +1030,11 @@ class WorkspaceComponentLoader {
     return err instanceof _legacy4().ComponentNotFound || err instanceof _legacy3().MissingBitMapComponent;
   }
   async executeLoadSlot(component, loadOpts) {
+    return (0, _harmonyModules3().loadSpan)('execute-load-slot', {
+      id: component.id.toString()
+    }, () => this.executeLoadSlotWithSpan(component, loadOpts));
+  }
+  async executeLoadSlotWithSpan(component, loadOpts) {
     if (component.state._consumer.removed) {
       // if it was soft-removed now, the component is not in the FS. loading aspects such as composition ends up with
       // errors as they try to read component files from the filesystem.
@@ -919,18 +1043,26 @@ class WorkspaceComponentLoader {
 
     // Special load events which runs from the workspace but should run from the correct aspect
     // TODO: remove this once those extensions dependent on workspace
-    const envsData = await this.envs.calcDescriptor(component, {
+    const envsData = await (0, _harmonyModules3().loadSpan)('env-calc', {}, () => this.envs.calcDescriptor(component, {
       skipWarnings: !!this.workspace.inInstallContext
-    });
+    }));
     const wsDeps = component.state._consumer.dependencies.dependencies || [];
     const modelDeps = component.state._consumer.componentFromModel?.dependencies.dependencies || [];
     const merged = _legacy2().Dependencies.merge([wsDeps, modelDeps]);
     const envExtendsDeps = merged.get();
 
     // Move to deps resolver main runtime once we switch ws<> deps resolver direction
-    const policy = await this.dependencyResolver.mergeVariantPolicies(component.config.extensions, component.id, component.state._consumer.files, envExtendsDeps);
-    const dependenciesList = await this.dependencyResolver.extractDepsFromLegacy(component, policy);
-    const resolvedEnvJsonc = await this.envs.calculateEnvManifest(component, component.state._consumer.files, envExtendsDeps);
+    const {
+      policy,
+      dependenciesList
+    } = await (0, _harmonyModules3().loadSpan)('dependency-resolution', {}, async () => {
+      const mergedPolicy = await this.dependencyResolver.mergeVariantPolicies(component.config.extensions, component.id, component.state._consumer.files, envExtendsDeps);
+      return {
+        policy: mergedPolicy,
+        dependenciesList: await this.dependencyResolver.extractDepsFromLegacy(component, mergedPolicy)
+      };
+    });
+    const resolvedEnvJsonc = await (0, _harmonyModules3().loadSpan)('env-manifest', {}, () => this.envs.calculateEnvManifest(component, component.state._consumer.files, envExtendsDeps));
     if (resolvedEnvJsonc) {
       // @ts-ignore
       envsData.resolvedEnvJsonc = resolvedEnvJsonc;
@@ -951,7 +1083,9 @@ class WorkspaceComponentLoader {
     component.state.aspects = aspectListWithEnvsAndDeps;
     const entries = this.workspace.onComponentLoadSlot.toArray();
     await (0, _pMapSeries().default)(entries, async ([extension, onLoad]) => {
-      const data = await onLoad(component, loadOpts);
+      const data = await (0, _harmonyModules3().loadSpan)('on-load', {
+        aspect: extension
+      }, () => onLoad(component, loadOpts));
       await this.upsertExtensionData(component, extension, data);
       // Update the aspect list to have changes happened during the on load slot (new data added above)
       component.state.aspects.upsertEntry(await this.workspace.resolveComponentId(extension), data);