chore: remove perf logs

Author: adityachoudhari26

apps/event-queue/src/index.ts

@@ -23,7 +23,6 @@ export const start = async () => {
 
   await consumer.run({
     eachMessage: async ({ topic, partition, message }) => {
-      const start = performance.now();
       logger.info("Received event", {
         topic,
         partition,
@@ -58,27 +57,12 @@ export const start = async () => {
         );
         await Promise.race([handler(event), timeoutPromise]);
 
-        const end = performance.now();
-        const duration = end - start;
-        if (duration >= 500) {
-          logger.warn("Handled event, but took longer than 500ms", {
-            duration: `${duration.toFixed(2)}ms`,
-            event,
-            eventType: event.eventType,
-          });
-          return;
-        }
-
         logger.info("Successfully handled event", {
-          duration: `${duration.toFixed(2)}ms`,
           event,
           eventType: event.eventType,
         });
       } catch (error) {
-        const end = performance.now();
-        const duration = end - start;
         logger.error("Failed to handle event", {
-          duration: `${duration.toFixed(2)}ms`,
           error: error instanceof Error ? error.message : error,
           stack: error instanceof Error ? error.stack : undefined,
           event,

apps/event-queue/src/job-manager/job-manager.ts

@@ -208,7 +208,6 @@ export class JobManager {
 
   @Trace()
   async createReleaseJob(release: typeof schema.release.$inferSelect) {
-    const start = performance.now();
     const versionRelease =
       await this.workspace.repository.versionReleaseRepository.get(
         release.versionReleaseId,
@@ -236,9 +235,6 @@ export class JobManager {
       jobVariables,
     );
 
-    const end = performance.now();
-    const duration = end - start;
-    this.log.info(`Creating release job took ${duration.toFixed(2)}ms`);
     return job;
   }
 

apps/event-queue/src/release-targets/evaluate/variable-release-manager.ts

@@ -105,7 +105,6 @@ export class VariableReleaseManager implements ReleaseManager {
 
   @Trace()
   async upsertRelease(variables: MaybeVariable[]) {
-    const now = performance.now();
     const latestRelease = await this.findLatestRelease();
 
     const oldVars = _(latestRelease?.values ?? [])
@@ -124,18 +123,12 @@ export class VariableReleaseManager implements ReleaseManager {
 
     const isSame = _.isEqual(oldVars, newVars);
     if (latestRelease != null && isSame) {
-      const end = performance.now();
-      const duration = end - now;
-      log.info(`Variable release upsert took ${duration.toFixed(2)}ms`);
       return { created: false, release: latestRelease };
     }
 
     const release = await this.insertRelease(this.releaseTarget.id);
     const vars = _.compact(variables);
     if (vars.length === 0) {
-      const end = performance.now();
-      const duration = end - now;
-      log.info(`Variable release upsert took ${duration.toFixed(2)}ms`);
       return { created: true, release };
     }
     const valueSnapshots = await this.getValueSnapshotsForRelease(vars);
@@ -155,24 +148,17 @@ export class VariableReleaseManager implements ReleaseManager {
       ),
     );
 
-    const end = performance.now();
-    const duration = end - now;
-    log.info(`Variable release upsert took ${duration.toFixed(2)}ms`);
     return { created: true, release };
   }
 
   @Trace()
   async evaluate() {
     try {
-      const now = performance.now();
       const variableManager = await getVariableManager(
         this.workspace,
         this.releaseTarget,
       );
       const variables = await variableManager.getVariables();
-      const end = performance.now();
-      const duration = end - now;
-      log.info(`Variable release evaluation took ${duration.toFixed(2)}ms`);
       return { chosenCandidate: variables };
     } catch (error) {
       log.error("Error evaluating variable release", { error });

apps/event-queue/src/release-targets/evaluate/variables/deployment-variable-provider.ts

@@ -32,7 +32,6 @@ export class DeploymentVariableProvider implements VariableProvider {
 
   @Trace()
   private async getRuleByReference(reference: string) {
-    const now = performance.now();
     const allRelationshipRules =
       await this.workspace.repository.resourceRelationshipRuleRepository.getAll();
     const relationshipRule = allRelationshipRules.find(
@@ -59,11 +58,6 @@ export class DeploymentVariableProvider implements VariableProvider {
       (r) => r.resourceRelationshipRuleId === relationshipRule.id,
     );
 
-    const end = performance.now();
-    const duration = end - now;
-    log.info(
-      `Getting relationship rule by reference took ${duration.toFixed(2)}ms`,
-    );
     return {
       ...relationshipRule,
       metadataKeysMatch,
@@ -77,7 +71,6 @@ export class DeploymentVariableProvider implements VariableProvider {
     relationshipRule: schema.ResourceRelationshipRule,
     targetMetadataEqualsRules: schema.ResourceRelationshipRuleTargetMetadataEquals[],
   ) {
-    const now = performance.now();
     const { resource } = this.releaseTarget;
     const { targetKind, targetVersion } = relationshipRule;
     const targetKindSatisfied =
@@ -91,17 +84,13 @@ export class DeploymentVariableProvider implements VariableProvider {
       if (targetMetadata == null || targetMetadata !== t.value) return false;
     }
 
-    const end = performance.now();
-    const duration = end - now;
-    log.info(`Target resource matches rule took ${duration.toFixed(2)}ms`);
     return true;
   }
 
   @Trace()
   private async getSourceResourceCandidates(
     relationshipRule: schema.ResourceRelationshipRule,
   ) {
-    const now = performance.now();
     const { sourceKind, sourceVersion } = relationshipRule;
     const allResources =
       await this.workspace.repository.resourceRepository.getAll();
@@ -111,11 +100,6 @@ export class DeploymentVariableProvider implements VariableProvider {
         r.version === sourceVersion &&
         r.deletedAt == null,
     );
-    const end = performance.now();
-    const duration = end - now;
-    log.info(
-      `Getting source resource candidates took ${duration.toFixed(2)}ms`,
-    );
     return resources;
   }
 
@@ -184,27 +168,16 @@ export class DeploymentVariableProvider implements VariableProvider {
       await this.getSourceResourceCandidates(relationshipRule);
     if (sourceResourceCandidates.length === 0) return defaultValue;
 
-    const sourceResourceSearchStart = performance.now();
     const sourceResource = sourceResourceCandidates.find((r) =>
       this.sourceResourceMatchesRule(
         sourceMetadataEquals,
         metadataKeysMatch,
         r,
       ),
     );
-    const sourceResourceSearchEnd = performance.now();
-    const sourceResourceSearchDuration =
-      sourceResourceSearchEnd - sourceResourceSearchStart;
-    log.info(
-      `Source resource search took ${sourceResourceSearchDuration.toFixed(2)}ms`,
-    );
     if (sourceResource == null) return defaultValue;
 
-    const fullSourceStart = performance.now();
     const fullSource = await this.getFullSource(sourceResource);
-    const fullSourceEnd = performance.now();
-    const fullSourceDuration = fullSourceEnd - fullSourceStart;
-    log.info(`Full source retrieval took ${fullSourceDuration.toFixed(2)}ms`);
     const resolvedPath = _.get(fullSource, path, defaultValue);
     return resolvedPath as string | number | boolean | object | null;
   }
@@ -238,19 +211,13 @@ export class DeploymentVariableProvider implements VariableProvider {
 
   @Trace()
   private async getDeploymentVariable(key: string) {
-    const now = performance.now();
     const allDeploymentVariables =
       await this.workspace.repository.deploymentVariableRepository.getAll();
     const deploymentVariable = allDeploymentVariables.find(
       (v) =>
         v.deploymentId === this.releaseTarget.deploymentId && v.key === key,
     );
     if (deploymentVariable == null) {
-      const end = performance.now();
-      const duration = end - now;
-      log.info(
-        `Getting actual deployment variable took ${duration.toFixed(2)}ms`,
-      );
       return null;
     }
     const allDeploymentVariableValues =
@@ -261,11 +228,6 @@ export class DeploymentVariableProvider implements VariableProvider {
     const defaultValue = values.find(
       (value) => value.id === deploymentVariable.defaultValueId,
     );
-    const end = performance.now();
-    const duration = end - now;
-    log.info(
-      `Getting actual deployment variable took ${duration.toFixed(2)}ms`,
-    );
     return { ...deploymentVariable, values, defaultValue };
   }
 
@@ -281,20 +243,10 @@ export class DeploymentVariableProvider implements VariableProvider {
     const { resource } = this.releaseTarget;
     for (const value of sortedValues) {
       if (value.resourceSelector == null) continue;
-      const matchStart = performance.now();
       const match = resourceMatchesSelector(resource, value.resourceSelector);
-      const matchEnd = performance.now();
-      const matchDuration = matchEnd - matchStart;
-      log.info(`Resource matches selector took ${matchDuration.toFixed(2)}ms`);
       if (!match) continue;
 
-      const resolveStart = performance.now();
       const resolvedValue = await this.resolveVariableValue(key, value);
-      const resolveEnd = performance.now();
-      const resolveDuration = resolveEnd - resolveStart;
-      log.info(
-        `Resolving deployment variable value took ${resolveDuration.toFixed(2)}ms`,
-      );
       if (resolvedValue != null) return resolvedValue;
     }
 

apps/event-queue/src/release-targets/evaluate/variables/resource-variable-provider.ts

@@ -45,15 +45,11 @@ export class ResourceVariableProvider implements VariableProvider {
 
   @Trace()
   async getVariable(key: string): Promise<MaybeVariable> {
-    const now = performance.now();
     const variables = await this.getVariables();
     const variable = variables.find((v) => v.key === key) ?? null;
     if (variable == null) return null;
 
     const resolvedValue = this.resolveVariableValue(variable);
-    const end = performance.now();
-    const duration = end - now;
-    log.info(`Resource variable resolution took ${duration.toFixed(2)}ms`);
 
     return {
       id: variable.id,

apps/event-queue/src/release-targets/manager.ts

@@ -51,7 +51,6 @@ export class ReleaseTargetManager {
   }
 
   private async determineReleaseTargets() {
-    const determineReleaseTargetsStart = performance.now();
     const [environments, deployments] = await Promise.all([
       this.getEnvironments(),
       this.getDeployments(),
@@ -108,13 +107,6 @@ export class ReleaseTargetManager {
       }
     }
 
-    const determineReleaseTargetsEnd = performance.now();
-    const determineReleaseTargetsDuration =
-      determineReleaseTargetsEnd - determineReleaseTargetsStart;
-    log.info(
-      `Determining release targets took ${determineReleaseTargetsDuration.toFixed(2)}ms`,
-    );
-
     return releaseTargets;
   }
 
@@ -125,7 +117,6 @@ export class ReleaseTargetManager {
   private async persistAddedReleaseTargets(
     releaseTargets: FullReleaseTarget[],
   ) {
-    const persistAddedReleaseTargetsStart = performance.now();
     await Promise.all(
       releaseTargets.map((releaseTarget) =>
         this.workspace.repository.releaseTargetRepository.create(releaseTarget),
@@ -139,18 +130,11 @@ export class ReleaseTargetManager {
         ),
       ),
     );
-    const persistAddedReleaseTargetsEnd = performance.now();
-    const persistAddedReleaseTargetsDuration =
-      persistAddedReleaseTargetsEnd - persistAddedReleaseTargetsStart;
-    log.info(
-      `Persisting added release targets took ${persistAddedReleaseTargetsDuration.toFixed(2)}ms`,
-    );
   }
 
   private async persistRemovedReleaseTargets(
     releaseTargets: FullReleaseTarget[],
   ) {
-    const persistRemovedReleaseTargetsStart = performance.now();
     await Promise.all(
       releaseTargets.map((releaseTarget) =>
         this.workspace.repository.releaseTargetRepository.delete(
@@ -166,32 +150,16 @@ export class ReleaseTargetManager {
         ),
       ),
     );
-    const persistRemovedReleaseTargetsEnd = performance.now();
-    const persistRemovedReleaseTargetsDuration =
-      persistRemovedReleaseTargetsEnd - persistRemovedReleaseTargetsStart;
-    log.info(
-      `Persisting removed release targets took ${persistRemovedReleaseTargetsDuration.toFixed(2)}ms`,
-    );
   }
 
   async computeReleaseTargetChanges() {
     log.info("Computing release target changes");
-    const start = performance.now();
 
-    const getCurrentStateStart = performance.now();
     const [existingReleaseTargets, computedReleaseTargets] = await Promise.all([
       this.getExistingReleaseTargets(),
       this.determineReleaseTargets(),
     ]);
 
-    const getCurrentStateEnd = performance.now();
-    const getCurrentStateDuration = getCurrentStateEnd - getCurrentStateStart;
-    log.info(
-      `Getting current state took ${getCurrentStateDuration.toFixed(2)}ms`,
-    );
-
-    const computeChangesStart = performance.now();
-
     const removedReleaseTargets = existingReleaseTargets.filter(
       (existingReleaseTarget) =>
         !computedReleaseTargets.some(
@@ -218,19 +186,11 @@ export class ReleaseTargetManager {
         ),
     );
 
-    const computeChangesEnd = performance.now();
-    const computeChangesDuration = computeChangesEnd - computeChangesStart;
-    log.info(`Computing changes took ${computeChangesDuration.toFixed(2)}ms`);
-
     await Promise.all([
       this.persistRemovedReleaseTargets(removedReleaseTargets),
       this.persistAddedReleaseTargets(addedReleaseTargets),
     ]);
 
-    const end = performance.now();
-    const duration = end - start;
-    log.info(`Release target changes computed took ${duration.toFixed(2)}ms`);
-
     return { removedReleaseTargets, addedReleaseTargets };
   }
 
@@ -239,26 +199,18 @@ export class ReleaseTargetManager {
   }
 
   private async handleVersionRelease(releaseTarget: FullReleaseTarget) {
-    const start = performance.now();
     const vrm = new VersionManager(releaseTarget, this.workspace);
     const { chosenCandidate } = await vrm.evaluate();
     if (chosenCandidate == null) return null;
     const { release } = await vrm.upsertRelease(chosenCandidate.id);
-    const end = performance.now();
-    const duration = end - start;
-    log.info(`Version release handled took ${duration.toFixed(2)}ms`);
     return release;
   }
 
   private async handleVariableRelease(releaseTarget: FullReleaseTarget) {
-    const start = performance.now();
     const rtWithWorkspace = this.getReleaseTargetWithWorkspace(releaseTarget);
     const varrm = new VariableReleaseManager(rtWithWorkspace, this.workspace);
     const { chosenCandidate } = await varrm.evaluate();
     const { release } = await varrm.upsertRelease(chosenCandidate);
-    const end = performance.now();
-    const duration = end - start;
-    log.info(`Variable release handled took ${duration.toFixed(2)}ms`);
     return release;
   }