refactor(server): telemetry (#13588)

refactor: telemetry

server/src/repositories/access.repository.ts

@@ -15,7 +15,6 @@ import { StackEntity } from 'src/entities/stack.entity';
 import { TagEntity } from 'src/entities/tag.entity';
 import { AlbumUserRole } from 'src/enum';
 import { IAccessRepository } from 'src/interfaces/access.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Brackets, In, Repository } from 'typeorm';
 
 type IActivityAccess = IAccessRepository['activity'];
@@ -29,7 +28,6 @@ type IStackAccess = IAccessRepository['stack'];
 type ITagAccess = IAccessRepository['tag'];
 type ITimelineAccess = IAccessRepository['timeline'];
 
-@Instrumentation()
 @Injectable()
 class ActivityAccess implements IActivityAccess {
   constructor(

server/src/repositories/activity.repository.ts

@@ -3,7 +3,6 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { ActivityEntity } from 'src/entities/activity.entity';
 import { IActivityRepository } from 'src/interfaces/activity.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { IsNull, Repository } from 'typeorm';
 
 export interface ActivitySearch {
@@ -13,7 +12,6 @@ export interface ActivitySearch {
   isLiked?: boolean;
 }
 
-@Instrumentation()
 @Injectable()
 export class ActivityRepository implements IActivityRepository {
   constructor(@InjectRepository(ActivityEntity) private repository: Repository<ActivityEntity>) {}

server/src/repositories/album-user.repository.ts

@@ -2,10 +2,8 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { AlbumUserEntity } from 'src/entities/album-user.entity';
 import { AlbumPermissionId, IAlbumUserRepository } from 'src/interfaces/album-user.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class AlbumUserRepository implements IAlbumUserRepository {
   constructor(@InjectRepository(AlbumUserEntity) private repository: Repository<AlbumUserEntity>) {}

server/src/repositories/album.repository.ts

@@ -4,7 +4,6 @@ import { Chunked, ChunkedArray, ChunkedSet, DummyValue, GenerateSql } from 'src/
 import { AlbumEntity } from 'src/entities/album.entity';
 import { AssetEntity } from 'src/entities/asset.entity';
 import { AlbumAssetCount, AlbumInfoOptions, IAlbumRepository } from 'src/interfaces/album.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import {
   DataSource,
   EntityManager,
@@ -23,7 +22,6 @@ const withoutDeletedUsers = <T extends AlbumEntity | null>(album: T) => {
   return album;
 };
 
-@Instrumentation()
 @Injectable()
 export class AlbumRepository implements IAlbumRepository {
   constructor(

server/src/repositories/api-key.repository.ts

@@ -3,10 +3,8 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { APIKeyEntity } from 'src/entities/api-key.entity';
 import { IKeyRepository } from 'src/interfaces/api-key.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class ApiKeyRepository implements IKeyRepository {
   constructor(@InjectRepository(APIKeyEntity) private repository: Repository<APIKeyEntity>) {}

server/src/repositories/asset.repository.ts

@@ -29,7 +29,6 @@ import {
 } from 'src/interfaces/asset.interface';
 import { AssetSearchOptions, SearchExploreItem } from 'src/interfaces/search.interface';
 import { searchAssetBuilder } from 'src/utils/database';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Paginated, PaginationOptions, paginate, paginatedBuilder } from 'src/utils/pagination';
 import {
   Brackets,
@@ -54,7 +53,6 @@ const dateTrunc = (options: TimeBucketOptions) =>
     truncateMap[options.size]
   }', (asset."localDateTime" at time zone 'UTC')) at time zone 'UTC')::timestamptz`;
 
-@Instrumentation()
 @Injectable()
 export class AssetRepository implements IAssetRepository {
   constructor(

server/src/repositories/audit.repository.ts

@@ -2,10 +2,8 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { AuditEntity } from 'src/entities/audit.entity';
 import { AuditSearch, IAuditRepository } from 'src/interfaces/audit.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { In, LessThan, MoreThan, Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class AuditRepository implements IAuditRepository {
   constructor(@InjectRepository(AuditEntity) private repository: Repository<AuditEntity>) {}

server/src/repositories/config.repository.ts

@@ -1,6 +1,7 @@
 import { Injectable } from '@nestjs/common';
 import { join } from 'node:path';
 import { citiesFile, excludePaths } from 'src/constants';
+import { Telemetry } from 'src/decorators';
 import { ImmichEnvironment, ImmichWorker, LogLevel } from 'src/enum';
 import { EnvData, IConfigRepository } from 'src/interfaces/config.interface';
 import { DatabaseExtension } from 'src/interfaces/database.interface';
@@ -74,9 +75,6 @@ const getEnv = (): EnvData => {
   const repoMetrics = parseBoolean(process.env.IMMICH_IO_METRICS, globalEnabled);
   const jobMetrics = parseBoolean(process.env.IMMICH_JOB_METRICS, globalEnabled);
   const telemetryEnabled = globalEnabled || hostMetrics || apiMetrics || repoMetrics || jobMetrics;
-  if (!telemetryEnabled && process.env.OTEL_SDK_DISABLED === undefined) {
-    process.env.OTEL_SDK_DISABLED = 'true';
-  }
 
   return {
     host: process.env.IMMICH_HOST,
@@ -186,6 +184,7 @@ const getEnv = (): EnvData => {
 let cached: EnvData | undefined;
 
 @Injectable()
+@Telemetry({ enabled: false })
 export class ConfigRepository implements IConfigRepository {
   getEnv(): EnvData {
     if (!cached) {

server/src/repositories/crypto.repository.ts

@@ -3,9 +3,7 @@ import { compareSync, hash } from 'bcrypt';
 import { createHash, createPublicKey, createVerify, randomBytes, randomUUID } from 'node:crypto';
 import { createReadStream } from 'node:fs';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 
-@Instrumentation()
 @Injectable()
 export class CryptoRepository implements ICryptoRepository {
   randomUUID() {

server/src/repositories/database.repository.ts

@@ -15,11 +15,9 @@ import {
   VectorUpdateResult,
 } from 'src/interfaces/database.interface';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { isValidInteger } from 'src/validation';
 import { DataSource, EntityManager, QueryRunner } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class DatabaseRepository implements IDatabaseRepository {
   private vectorExtension: VectorExtension;

server/src/repositories/event.repository.ts

@@ -24,7 +24,6 @@ import {
 } from 'src/interfaces/event.interface';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { AuthService } from 'src/services/auth.service';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { handlePromiseError } from 'src/utils/misc';
 
 type EmitHandlers = Partial<{ [T in EmitEvent]: Array<EventItem<T>> }>;
@@ -37,7 +36,6 @@ type Item<T extends EmitEvent> = {
   label: string;
 };
 
-@Instrumentation()
 @WebSocketGateway({
   cors: true,
   path: '/api/socket.io',

server/src/repositories/job.repository.ts

@@ -17,7 +17,6 @@ import {
   QueueStatus,
 } from 'src/interfaces/job.interface';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 
 export const JOBS_TO_QUEUE: Record<JobName, QueueName> = {
   // misc
@@ -99,7 +98,6 @@ export const JOBS_TO_QUEUE: Record<JobName, QueueName> = {
   [JobName.QUEUE_TRASH_EMPTY]: QueueName.BACKGROUND_TASK,
 };
 
-@Instrumentation()
 @Injectable()
 export class JobRepository implements IJobRepository {
   private workers: Partial<Record<QueueName, Worker>> = {};

server/src/repositories/library.repository.ts

@@ -4,11 +4,9 @@ import { DummyValue, GenerateSql } from 'src/decorators';
 import { LibraryStatsResponseDto } from 'src/dtos/library.dto';
 import { LibraryEntity } from 'src/entities/library.entity';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { IsNull, Not } from 'typeorm';
 import { Repository } from 'typeorm/repository/Repository.js';
 
-@Instrumentation()
 @Injectable()
 export class LibraryRepository implements ILibraryRepository {
   constructor(@InjectRepository(LibraryEntity) private repository: Repository<LibraryEntity>) {}

server/src/repositories/logger.repository.ts

@@ -1,6 +1,7 @@
 import { ConsoleLogger, Inject, Injectable, Scope } from '@nestjs/common';
 import { isLogLevelEnabled } from '@nestjs/common/services/utils/is-log-level-enabled.util';
 import { ClsService } from 'nestjs-cls';
+import { Telemetry } from 'src/decorators';
 import { LogLevel } from 'src/enum';
 import { IConfigRepository } from 'src/interfaces/config.interface';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
@@ -17,6 +18,7 @@ enum LogColor {
 }
 
 @Injectable({ scope: Scope.TRANSIENT })
+@Telemetry({ enabled: false })
 export class LoggerRepository extends ConsoleLogger implements ILoggerRepository {
   private static logLevels: LogLevel[] = [LogLevel.LOG, LogLevel.WARN, LogLevel.ERROR, LogLevel.FATAL];
   private noColor: boolean;

server/src/repositories/machine-learning.repository.ts

@@ -12,11 +12,9 @@ import {
   ModelTask,
   ModelType,
 } from 'src/interfaces/machine-learning.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 
 const errorPrefix = 'Machine learning request';
 
-@Instrumentation()
 @Injectable()
 export class MachineLearningRepository implements IMachineLearningRepository {
   private async predict<T>(url: string, payload: ModelPayload, config: MachineLearningRequest): Promise<T> {

server/src/repositories/map.repository.ts

@@ -20,11 +20,9 @@ import {
 } from 'src/interfaces/map.interface';
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
 import { OptionalBetween } from 'src/utils/database';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { DataSource, In, IsNull, Not, QueryRunner, Repository } from 'typeorm';
 import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity.js';
 
-@Instrumentation()
 @Injectable()
 export class MapRepository implements IMapRepository {
   constructor(

server/src/repositories/media.repository.ts

@@ -17,7 +17,6 @@ import {
   TranscodeCommand,
   VideoInfo,
 } from 'src/interfaces/media.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { handlePromiseError } from 'src/utils/misc';
 
 const probe = (input: string, options: string[]): Promise<FfprobeData> =>
@@ -36,7 +35,6 @@ type ProgressEvent = {
   percent?: number;
 };
 
-@Instrumentation()
 @Injectable()
 export class MediaRepository implements IMediaRepository {
   constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {

server/src/repositories/memory.repository.ts

@@ -3,10 +3,8 @@ import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { Chunked, ChunkedSet, DummyValue, GenerateSql } from 'src/decorators';
 import { MemoryEntity } from 'src/entities/memory.entity';
 import { IMemoryRepository } from 'src/interfaces/memory.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { DataSource, In, Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class MemoryRepository implements IMemoryRepository {
   constructor(

server/src/repositories/metadata.repository.ts

@@ -3,9 +3,7 @@ import { DefaultReadTaskOptions, ExifTool, Tags } from 'exiftool-vendored';
 import geotz from 'geo-tz';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMetadataRepository, ImmichTags } from 'src/interfaces/metadata.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 
-@Instrumentation()
 @Injectable()
 export class MetadataRepository implements IMetadataRepository {
   private exiftool = new ExifTool({

server/src/repositories/move.repository.ts

@@ -4,10 +4,8 @@ import { DummyValue, GenerateSql } from 'src/decorators';
 import { MoveEntity } from 'src/entities/move.entity';
 import { PathType } from 'src/enum';
 import { IMoveRepository, MoveCreate } from 'src/interfaces/move.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class MoveRepository implements IMoveRepository {
   constructor(@InjectRepository(MoveEntity) private repository: Repository<MoveEntity>) {}

server/src/repositories/notification.repository.ts

@@ -15,9 +15,7 @@ import {
   SendEmailResponse,
   SmtpOptions,
 } from 'src/interfaces/notification.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 
-@Instrumentation()
 @Injectable()
 export class NotificationRepository implements INotificationRepository {
   constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {

server/src/repositories/oauth.repository.ts

@@ -2,9 +2,7 @@ import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common
 import { custom, generators, Issuer } from 'openid-client';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IOAuthRepository, OAuthConfig, OAuthProfile } from 'src/interfaces/oauth.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 
-@Instrumentation()
 @Injectable()
 export class OAuthRepository implements IOAuthRepository {
   constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {

server/src/repositories/partner.repository.ts

@@ -2,10 +2,8 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { PartnerEntity } from 'src/entities/partner.entity';
 import { IPartnerRepository, PartnerIds } from 'src/interfaces/partner.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { DeepPartial, Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class PartnerRepository implements IPartnerRepository {
   constructor(@InjectRepository(PartnerEntity) private repository: Repository<PartnerEntity>) {}

server/src/repositories/person.repository.ts

@@ -20,11 +20,9 @@ import {
   UnassignFacesOptions,
   UpdateFacesData,
 } from 'src/interfaces/person.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Paginated, PaginationOptions, paginate, paginatedBuilder } from 'src/utils/pagination';
 import { DataSource, FindManyOptions, FindOptionsRelations, FindOptionsSelect, In, Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class PersonRepository implements IPersonRepository {
   constructor(

server/src/repositories/search.repository.ts

@@ -23,12 +23,10 @@ import {
   SmartSearchOptions,
 } from 'src/interfaces/search.interface';
 import { asVector, searchAssetBuilder } from 'src/utils/database';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Paginated, PaginationResult, paginatedBuilder } from 'src/utils/pagination';
 import { isValidInteger } from 'src/validation';
 import { Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class SearchRepository implements ISearchRepository {
   private vectorExtension: VectorExtension;

server/src/repositories/server-info.repository.ts

@@ -7,7 +7,6 @@ import sharp from 'sharp';
 import { IConfigRepository } from 'src/interfaces/config.interface';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { GitHubRelease, IServerInfoRepository, ServerBuildVersions } from 'src/interfaces/server-info.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 
 const exec = promisify(execCallback);
 const maybeFirstLine = async (command: string): Promise<string> => {
@@ -34,7 +33,6 @@ const getLockfileVersion = (name: string, lockfile?: BuildLockfile) => {
   return item?.version;
 };
 
-@Instrumentation()
 @Injectable()
 export class ServerInfoRepository implements IServerInfoRepository {
   constructor(

server/src/repositories/session.repository.ts

@@ -3,10 +3,8 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { SessionEntity } from 'src/entities/session.entity';
 import { ISessionRepository, SessionSearchOptions } from 'src/interfaces/session.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { LessThanOrEqual, Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class SessionRepository implements ISessionRepository {
   constructor(@InjectRepository(SessionEntity) private repository: Repository<SessionEntity>) {}

server/src/repositories/shared-link.repository.ts

@@ -3,10 +3,8 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { SharedLinkEntity } from 'src/entities/shared-link.entity';
 import { ISharedLinkRepository } from 'src/interfaces/shared-link.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class SharedLinkRepository implements ISharedLinkRepository {
   constructor(@InjectRepository(SharedLinkEntity) private repository: Repository<SharedLinkEntity>) {}

server/src/repositories/stack.repository.ts

@@ -3,10 +3,8 @@ import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { AssetEntity } from 'src/entities/asset.entity';
 import { StackEntity } from 'src/entities/stack.entity';
 import { IStackRepository, StackSearch } from 'src/interfaces/stack.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { DataSource, In, Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class StackRepository implements IStackRepository {
   constructor(

server/src/repositories/storage.repository.ts

@@ -14,10 +14,8 @@ import {
   ImmichZipStream,
   WatchEvents,
 } from 'src/interfaces/storage.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { mimeTypes } from 'src/utils/mime-types';
 
-@Instrumentation()
 @Injectable()
 export class StorageRepository implements IStorageRepository {
   constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {

server/src/repositories/system-metadata.repository.ts

@@ -3,10 +3,8 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { readFile } from 'node:fs/promises';
 import { SystemMetadata, SystemMetadataEntity } from 'src/entities/system-metadata.entity';
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class SystemMetadataRepository implements ISystemMetadataRepository {
   constructor(

server/src/repositories/tag.repository.ts

@@ -4,10 +4,8 @@ import { Chunked, ChunkedSet, DummyValue, GenerateSql } from 'src/decorators';
 import { TagEntity } from 'src/entities/tag.entity';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { AssetTagItem, ITagRepository } from 'src/interfaces/tag.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { DataSource, In, Repository, TreeRepository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class TagRepository implements ITagRepository {
   constructor(

server/src/repositories/telemetry.repository.ts

@@ -1,7 +1,22 @@
 import { Inject, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
 import { MetricOptions } from '@opentelemetry/api';
+import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
+import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import { IORedisInstrumentation } from '@opentelemetry/instrumentation-ioredis';
+import { NestInstrumentation } from '@opentelemetry/instrumentation-nestjs-core';
+import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';
+import { NodeSDK, contextBase, metrics, resources } from '@opentelemetry/sdk-node';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { ClassConstructor } from 'class-transformer';
+import { snakeCase, startCase } from 'lodash';
 import { MetricService } from 'nestjs-otel';
+import { copyMetadataFromFunctionToFunction } from 'nestjs-otel/lib/opentelemetry.utils';
+import { serverVersion } from 'src/constants';
+import { MetadataKey } from 'src/enum';
 import { IConfigRepository } from 'src/interfaces/config.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMetricGroupRepository, ITelemetryRepository, MetricGroupOptions } from 'src/interfaces/telemetry.interface';
 
 class MetricGroupRepository implements IMetricGroupRepository {
@@ -33,6 +48,43 @@ class MetricGroupRepository implements IMetricGroupRepository {
   }
 }
 
+const aggregation = new metrics.ExplicitBucketHistogramAggregation(
+  [0.1, 0.25, 0.5, 0.75, 1, 2.5, 5, 7.5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10_000],
+  true,
+);
+
+let instance: NodeSDK | undefined;
+
+export const bootstrapTelemetry = (port: number) => {
+  if (instance) {
+    throw new Error('OpenTelemetry SDK already started');
+  }
+  instance = new NodeSDK({
+    resource: new resources.Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: `immich`,
+      [SemanticResourceAttributes.SERVICE_VERSION]: serverVersion.toString(),
+    }),
+    metricReader: new PrometheusExporter({ port }),
+    contextManager: new AsyncLocalStorageContextManager(),
+    instrumentations: [
+      new HttpInstrumentation(),
+      new IORedisInstrumentation(),
+      new NestInstrumentation(),
+      new PgInstrumentation(),
+    ],
+    views: [new metrics.View({ aggregation, instrumentName: '*', instrumentUnit: 'ms' })],
+  });
+
+  instance.start();
+};
+
+export const teardownTelemetry = async () => {
+  if (instance) {
+    await instance.shutdown();
+    instance = undefined;
+  }
+};
+
 @Injectable()
 export class TelemetryRepository implements ITelemetryRepository {
   api: MetricGroupRepository;
@@ -40,8 +92,13 @@ export class TelemetryRepository implements ITelemetryRepository {
   jobs: MetricGroupRepository;
   repo: MetricGroupRepository;
 
-  constructor(metricService: MetricService, @Inject(IConfigRepository) configRepository: IConfigRepository) {
-    const { telemetry } = configRepository.getEnv();
+  constructor(
+    private metricService: MetricService,
+    private reflect: Reflector,
+    @Inject(IConfigRepository) private configRepository: IConfigRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    const { telemetry } = this.configRepository.getEnv();
     const { apiMetrics, hostMetrics, jobMetrics, repoMetrics } = telemetry;
 
     this.api = new MetricGroupRepository(metricService).configure({ enabled: apiMetrics });
@@ -49,4 +106,61 @@ export class TelemetryRepository implements ITelemetryRepository {
     this.jobs = new MetricGroupRepository(metricService).configure({ enabled: jobMetrics });
     this.repo = new MetricGroupRepository(metricService).configure({ enabled: repoMetrics });
   }
+
+  setup({ repositories }: { repositories: ClassConstructor<unknown>[] }) {
+    const { telemetry } = this.configRepository.getEnv();
+    if (!telemetry.enabled || !telemetry.repoMetrics) {
+      return;
+    }
+
+    for (const Repository of repositories) {
+      const isEnabled = this.reflect.get(MetadataKey.TELEMETRY_ENABLED, Repository) ?? true;
+      if (!isEnabled) {
+        this.logger.debug(`Telemetry disabled for ${Repository.name}`);
+        continue;
+      }
+
+      this.wrap(Repository);
+    }
+  }
+
+  private wrap(Repository: ClassConstructor<unknown>) {
+    const className = Repository.name;
+    const descriptors = Object.getOwnPropertyDescriptors(Repository.prototype);
+    const unit = 'ms';
+
+    for (const [propName, descriptor] of Object.entries(descriptors)) {
+      const isMethod = typeof descriptor.value == 'function' && propName !== 'constructor';
+      if (!isMethod) {
+        continue;
+      }
+
+      const method = descriptor.value;
+      const propertyName = snakeCase(String(propName));
+      const metricName = `${snakeCase(className).replaceAll(/_(?=(repository)|(controller)|(provider)|(service)|(module))/g, '.')}.${propertyName}.duration`;
+
+      const histogram = this.metricService.getHistogram(metricName, {
+        prefix: 'immich',
+        description: `The elapsed time in ${unit} for the ${startCase(className)} to ${propertyName.toLowerCase()}`,
+        unit,
+        valueType: contextBase.ValueType.DOUBLE,
+      });
+
+      descriptor.value = function (...args: any[]) {
+        const start = performance.now();
+        const result = method.apply(this, args);
+
+        void Promise.resolve(result)
+          .then(() => histogram.record(performance.now() - start, {}))
+          .catch(() => {
+            // noop
+          });
+
+        return result;
+      };
+
+      copyMetadataFromFunctionToFunction(method, descriptor.value);
+      Object.defineProperty(Repository.prototype, propName, descriptor);
+    }
+  }
 }

server/src/repositories/user.repository.ts

@@ -10,10 +10,8 @@ import {
   UserListFilter,
   UserStatsQueryResponse,
 } from 'src/interfaces/user.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { IsNull, Not, Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class UserRepository implements IUserRepository {
   constructor(

server/src/repositories/version-history.repository.ts

@@ -2,10 +2,8 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { VersionHistoryEntity } from 'src/entities/version-history.entity';
 import { IVersionHistoryRepository } from 'src/interfaces/version-history.interface';
-import { Instrumentation } from 'src/utils/instrumentation';
 import { Repository } from 'typeorm';
 
-@Instrumentation()
 @Injectable()
 export class VersionHistoryRepository implements IVersionHistoryRepository {
   constructor(@InjectRepository(VersionHistoryEntity) private repository: Repository<VersionHistoryEntity>) {}