@futo-org/backups-orchestrator-api 0.1.72 → 0.4.0

package/dist/services/repository.service.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { FilesystemListingRequestDto, FilesystemListingResponseDto } from '../dto/filesystem.dto';
-import { ListSnapshotsResponseDto, RepositoryCheckImportResponseDto, RepositoryCreateRequestDto, RepositoryCreateResponseDto, RepositoryInspectResponseDto, RepositoryListResponseDto, RepositorySnapshotRestoreFromPointRequestDto, RepositorySnapshotRestoreRequestDto, RepositoryUpdateRequestDto, RepositoryUpdateResponseDto, RunHistoryResponseDto } from '../dto/repository.dto';
+import { ListSnapshotsResponseDto, RepositoryCheckImportResponseDto, RepositoryCreateRequestDto, RepositoryCreateResponseDto, RepositoryInspectResponseDto, RepositoryListResponseDto, RepositoryPrimaryBackendReconfigureRequestDto, RepositorySnapshotRestoreFromPointRequestDto, RepositorySnapshotRestoreRequestDto, RepositoryUpdateRequestDto, RepositoryUpdateResponseDto, RunHistoryResponseDto } from '../dto/repository.dto';
 import { EventsGateway } from '../events/events.gateway';
 import { BackendRepository } from '../repositories/backend.repository';
 import { ConfigRepository } from '../repositories/config.repository';
@@ -14,6 +14,7 @@ import { RunHistoryRepository } from '../repositories/runHistory.repository';
 import { RunningTasksRepository } from '../repositories/runningTasks.repository';
 import { StorageRepository } from '../repositories/storage.repository';
 import { BootstrapService } from './bootstrap.service';
+import { TelemetryService } from './telemetry.service';
 export declare class RepositoryService {
     private readonly tasks;
     private readonly events;
@@ -28,11 +29,12 @@ export declare class RepositoryService {
     private readonly moduleConfig;
     private readonly storage;
     private readonly bootstrap;
-    constructor(tasks: RunningTasksRepository, events: EventsGateway, backend: BackendRepository, config: ConfigRepository, database: DatabaseRepository, restic: ResticRepository, runHistory: RunHistoryRepository, repository: RepositoryRepository, repositoryPath: RepositoryPathRepository, repositoryLocalMetrics: RepositoryLocalMetricsRepository, moduleConfig: ModuleConfigRepository, storage: StorageRepository, bootstrap: BootstrapService);
+    private readonly telemetry;
+    constructor(tasks: RunningTasksRepository, events: EventsGateway, backend: BackendRepository, config: ConfigRepository, database: DatabaseRepository, restic: ResticRepository, runHistory: RunHistoryRepository, repository: RepositoryRepository, repositoryPath: RepositoryPathRepository, repositoryLocalMetrics: RepositoryLocalMetricsRepository, moduleConfig: ModuleConfigRepository, storage: StorageRepository, bootstrap: BootstrapService, telemetry: TelemetryService);
     private getLocalRepository;
     createRepository(dto: RepositoryCreateRequestDto, backendId?: string): Promise<RepositoryCreateResponseDto>;
     getRepositories(): Promise<RepositoryListResponseDto>;
-    inspectRepositories(): Promise<RepositoryInspectResponseDto>;
+    inspectRepositories(backendId?: string): Promise<RepositoryInspectResponseDto>;
     private mapSnapshot;
     updateRepository(id: string, dto: RepositoryUpdateRequestDto, backendId?: string): Promise<RepositoryUpdateResponseDto>;
     deleteRepository(id: string): Promise<void>;
@@ -49,6 +51,7 @@ export declare class RepositoryService {
     }>;
     checkImportRepository(id: string, backendId: string): Promise<RepositoryCheckImportResponseDto>;
     importRepository(id: string, backendId: string): Promise<RepositoryCreateResponseDto>;
+    reconfigureRepositoryPrimaryBackend(id: string, dto: RepositoryPrimaryBackendReconfigureRequestDto): Promise<RepositoryCreateResponseDto>;
     getSnapshots(id: string): Promise<ListSnapshotsResponseDto>;
     restoreSnapshot(id: string, snapshotId: string, dto: RepositorySnapshotRestoreRequestDto): Promise<{
         logId: string;

package/dist/services/repository.service.js

@@ -14,8 +14,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RepositoryService = void 0;
 const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
 const node_path_1 = require("node:path");
-const backend_1 = require("../backends/backend");
 const enum_1 = require("../enum");
 const events_gateway_1 = require("../events/events.gateway");
 const backend_repository_1 = require("../repositories/backend.repository");
@@ -31,6 +31,7 @@ const runningTasks_repository_1 = require("../repositories/runningTasks.reposito
 const storage_repository_1 = require("../repositories/storage.repository");
 const restic_1 = require("../utils/restic");
 const bootstrap_service_1 = require("./bootstrap.service");
+const telemetry_service_1 = require("./telemetry.service");
 let RepositoryService = class RepositoryService {
     tasks;
     events;
@@ -45,7 +46,8 @@ let RepositoryService = class RepositoryService {
     moduleConfig;
     storage;
     bootstrap;
-    constructor(tasks, events, backend, config, database, restic, runHistory, repository, repositoryPath, repositoryLocalMetrics, moduleConfig, storage, bootstrap) {
+    telemetry;
+    constructor(tasks, events, backend, config, database, restic, runHistory, repository, repositoryPath, repositoryLocalMetrics, moduleConfig, storage, bootstrap, telemetry) {
         this.tasks = tasks;
         this.events = events;
         this.backend = backend;
@@ -59,6 +61,7 @@ let RepositoryService = class RepositoryService {
         this.moduleConfig = moduleConfig;
         this.storage = storage;
         this.bootstrap = bootstrap;
+        this.telemetry = telemetry;
     }
     async getLocalRepository(id, configuration, metrics) {
         if (!configuration) {
@@ -76,24 +79,26 @@ let RepositoryService = class RepositoryService {
             const backends = await this.backend.getBackends();
             backendId = backends[0].id;
         }
-        const { configuration } = await this.backend.getBackend(backendId);
-        const backend = backend_1.Backend.from(configuration, this.moduleConfig.get());
+        const { backend, configuration } = await this.backend.getBackend(backendId);
         const { repository: remote } = await backend.createRepository(dto);
+        const id = (0, node_crypto_1.randomUUID)();
         const endpoint = await backend.getResticEndpoint(remote.id);
         const key = await this.config.deriveEncryptionKey(`repository-${remote.id}`);
         await this.restic.init(endpoint, key);
         await this.repository.create({
-            id: remote.id,
+            id,
+            remoteId: remote.id,
             backendId,
             retentionPolicy: restic_1.DEFAULT_RETENTION_POLICY,
         });
         const paths = dto.paths ?? [];
         for (const path of paths) {
-            await this.repositoryPath.create({ id: remote.id, path });
+            await this.repositoryPath.create({ id, path });
         }
         const repository = {
-            ...(await this.getLocalRepository(remote.id, { paths, retentionPolicy: restic_1.DEFAULT_RETENTION_POLICY })),
+            ...(await this.getLocalRepository(id, { paths, retentionPolicy: restic_1.DEFAULT_RETENTION_POLICY })),
             ...remote,
+            id,
             backends: {
                 primary: {
                     id: backendId,
@@ -103,6 +108,10 @@ let RepositoryService = class RepositoryService {
                 secondary: [],
             },
         };
+        this.telemetry.submitStructuredLog('Created repository', {
+            repositoryId: remote.id,
+            backendId,
+        });
         this.events.publish({
             type: 'RepositoryCreate',
             repository,
@@ -116,8 +125,7 @@ let RepositoryService = class RepositoryService {
         const repositories = [];
         const backendsById = Object.fromEntries(backends.map((backend) => [backend.id, backend]));
         const remoteRepositories = {};
-        for (const { id: backendId, configuration } of backends) {
-            const backend = backend_1.Backend.from(configuration, this.moduleConfig.get());
+        for (const { id: backendId, backend } of backends) {
             remoteRepositories[backendId] = {};
             try {
                 const { repositories: list } = await backend.getRepositories();
@@ -132,8 +140,8 @@ let RepositoryService = class RepositoryService {
         const localRepositories = await this.repository.getAll();
         const localPaths = await this.repositoryPath.getAll();
         const localMetrics = await this.repositoryLocalMetrics.getAll();
-        for (const { id, backendId, retentionPolicy } of localRepositories) {
-            const remoteRepository = remoteRepositories[backendId][id];
+        for (const { id, remoteId, backendId, retentionPolicy } of localRepositories) {
+            const remoteRepository = remoteRepositories[backendId][remoteId];
             const configuration = {
                 paths: localPaths.filter((entry) => entry.id === id).map(({ path }) => path),
                 retentionPolicy,
@@ -142,6 +150,7 @@ let RepositoryService = class RepositoryService {
             if (remoteRepository) {
                 repositories.push({
                     ...remoteRepository,
+                    id,
                     ...(await this.getLocalRepository(id, configuration, metrics)),
                     backends: {
                         primary: {
@@ -152,7 +161,7 @@ let RepositoryService = class RepositoryService {
                         secondary: [],
                     },
                 });
-                delete remoteRepositories[backendId][id];
+                delete remoteRepositories[backendId][remoteId];
             }
             else {
                 repositories.push({
@@ -190,14 +199,20 @@ let RepositoryService = class RepositoryService {
             repositories,
         };
     }
-    async inspectRepositories() {
+    async inspectRepositories(backendId) {
         const { repositories } = await this.getRepositories();
-        const snapshots = await Promise.allSettled(repositories.map(async (repository) => {
-            const { endpoint, key } = await this.getResticParameters(repository.id, repository.backends?.primary.id);
+        const list = repositories.filter((repository) => !repository.configuration &&
+            repository.backends &&
+            (!backendId || repository.backends.primary.id === backendId));
+        const snapshots = await Promise.allSettled(list.map(async (repository) => {
+            const { endpoint, key } = await this.getResticParameters({
+                backendId: repository.backends.primary.id,
+                remoteId: repository.id,
+            });
             return this.restic.snapshots(endpoint, key);
         }));
         return {
-            repositories: repositories.map((repository, idx) => ({
+            repositories: list.map((repository, idx) => ({
                 ...repository,
                 snapshots: snapshots[idx].status === 'fulfilled'
                     ? snapshots[idx].value.map((snapshot) => this.mapSnapshot(snapshot))
@@ -222,18 +237,22 @@ let RepositoryService = class RepositoryService {
         };
     }
     async updateRepository(id, dto, backendId) {
-        if (!backendId) {
+        let remoteId;
+        if (backendId) {
+            remoteId = id;
+        }
+        else {
             const localRepository = await this.repository.get(id);
             backendId = localRepository.backendId;
+            remoteId = localRepository.remoteId;
         }
-        const backend = await this.backend.getBackend(backendId);
-        const backendInstance = backend_1.Backend.from(backend.configuration, this.moduleConfig.get());
+        const { backend, configuration } = await this.backend.getBackend(backendId);
         let remote;
         if (dto.name) {
-            ({ repository: remote } = await backendInstance.updateRepository(id, dto));
+            ({ repository: remote } = await backend.updateRepository(remoteId, dto));
         }
         else {
-            ({ repository: remote } = await backendInstance.getRepository(id));
+            ({ repository: remote } = await backend.getRepository(remoteId));
         }
         if (dto.paths) {
             const currentPaths = new Set(await this.repositoryPath.get(id));
@@ -256,16 +275,20 @@ let RepositoryService = class RepositoryService {
         const metrics = await this.repositoryLocalMetrics.get(id);
         const repository = {
             ...remote,
+            id,
             ...(await this.getLocalRepository(id, undefined, metrics)),
             backends: {
                 primary: {
                     id: backendId,
-                    type: backend.configuration.type,
+                    type: configuration.type,
                     online: true,
                 },
                 secondary: [],
             },
         };
+        this.telemetry.submitStructuredLog('Updated repository', {
+            repositoryId: id,
+        });
         this.events.publish({
             type: 'RepositoryUpdate',
             repositoryId: id,
@@ -277,23 +300,31 @@ let RepositoryService = class RepositoryService {
     }
     async deleteRepository(id) {
         await this.repository.delete(id);
+        this.telemetry.submitStructuredLog('Deleted repository', {
+            repositoryId: id,
+        });
         this.events.publish({
             type: 'RepositoryDelete',
             repositoryId: id,
         });
     }
-    async getResticParameters(id, backendId) {
-        if (!backendId) {
-            const localRepository = await this.repository.get(id);
+    async getResticParameters(repository) {
+        let backendId;
+        let remoteId;
+        if (typeof repository === 'string') {
+            const localRepository = await this.repository.get(repository);
             if (!localRepository) {
                 throw new common_1.BadRequestException('Repository not found locally');
             }
             backendId = localRepository.backendId;
+            remoteId = localRepository.remoteId;
+        }
+        else {
+            ({ backendId, remoteId } = repository);
         }
-        const backend = await this.backend.getBackend(backendId);
-        const backendInstance = backend_1.Backend.from(backend.configuration, this.moduleConfig.get());
-        const endpoint = await backendInstance.getResticEndpoint(id);
-        const key = await this.config.deriveEncryptionKey(`repository-${id}`);
+        const { backend } = await this.backend.getBackend(backendId);
+        const endpoint = await backend.getResticEndpoint(remoteId);
+        const key = await this.config.deriveEncryptionKey(`repository-${remoteId}`);
         return { endpoint, key };
     }
     async updateLocalMetrics(id, options) {
@@ -315,11 +346,10 @@ let RepositoryService = class RepositoryService {
                 },
             });
             if (metrics.sizeBytes) {
-                const { backendId } = await this.repository.get(id);
-                const { configuration } = await this.backend.getBackend(backendId);
-                const backend = backend_1.Backend.from(configuration, this.moduleConfig.get());
+                const { backendId, remoteId } = await this.repository.get(id);
+                const { backend } = await this.backend.getBackend(backendId);
                 if (backend.isMetricsCapable()) {
-                    await backend.submitMetricRepositorySize(id, metrics.sizeBytes);
+                    await backend.submitMetricRepositorySize(remoteId, metrics.sizeBytes);
                 }
             }
         }
@@ -328,11 +358,16 @@ let RepositoryService = class RepositoryService {
     }
     async createBackup(id, signal) {
         if (!this.tasks.canStart(id)) {
+            this.telemetry.submitStructuredLog('Backup rejected, task already running', {
+                repositoryId: id,
+            });
             throw new common_1.BadRequestException('Task already running!');
         }
-        const { backendId } = await this.repository.get(id);
-        const { configuration } = await this.backend.getBackend(backendId);
-        const backend = backend_1.Backend.from(configuration, this.moduleConfig.get());
+        this.telemetry.submitStructuredLog('Running backup', {
+            repositoryId: id,
+        });
+        const { backendId, remoteId } = await this.repository.get(id);
+        const { backend } = await this.backend.getBackend(backendId);
         const { endpoint, key } = await this.getResticParameters(id);
         const paths = await this.repositoryPath.get(id);
         if (paths.length === 0) {
@@ -346,15 +381,22 @@ let RepositoryService = class RepositoryService {
                     logId,
                 });
                 if (backend.isMetricsCapable()) {
-                    await backend.submitMetricBackupStart(id);
+                    await backend.submitMetricBackupStart(remoteId);
                 }
                 try {
                     const taskSignal = this.tasks.startTask(id, enum_1.TaskType.Backup, logId, signal);
                     await this.restic.unlockAll(endpoint, key);
-                    await this.restic.backup(endpoint, key, paths, log, taskSignal);
+                    const summary = await this.restic.backup(endpoint, key, paths, log, taskSignal);
+                    this.telemetry.submitStructuredLog('Finished backup to primary backend', {
+                        repositoryId: id,
+                        summary,
+                    });
                     const { retentionPolicy: policy } = await this.repository.get(id);
                     if (policy) {
                         await this.runForgetAndPrune(endpoint, key, policy, log, taskSignal);
+                        this.telemetry.submitStructuredLog('Finished prune on primary backend', {
+                            repositoryId: id,
+                        });
                     }
                 }
                 finally {
@@ -372,6 +414,10 @@ let RepositoryService = class RepositoryService {
                         lastBackupDuration,
                     },
                 });
+                this.telemetry.submitStructuredLog('Backup finished', {
+                    repositoryId: id,
+                    error,
+                });
                 if (error) {
                     fail(error);
                 }
@@ -379,7 +425,7 @@ let RepositoryService = class RepositoryService {
                     complete();
                 }
                 if (backend.isMetricsCapable()) {
-                    await backend.submitMetricBackupEnd(id, !error, lastBackupDuration);
+                    await backend.submitMetricBackupEnd(remoteId, !error, lastBackupDuration);
                 }
             }));
             task.catch(() => { });
@@ -408,22 +454,39 @@ let RepositoryService = class RepositoryService {
     }
     async pruneRepository(id, signal) {
         if (!this.tasks.canStart(id)) {
+            this.telemetry.submitStructuredLog('Repository prune rejected, task already running', {
+                repositoryId: id,
+            });
             throw new common_1.BadRequestException('Task already running!');
         }
         const { retentionPolicy: policy } = await this.repository.get(id);
         if (!policy) {
             throw new common_1.BadRequestException('No retention policy configured for this repository');
         }
+        this.telemetry.submitStructuredLog('Running repository prune', {
+            repositoryId: id,
+            retentionPolicy: policy,
+        });
         const { endpoint, key } = await this.getResticParameters(id);
         return new Promise((resolve) => {
             const task = new Promise((complete, fail) => void this.runHistory.createLog(id, enum_1.TaskType.Forget, async (log, logId) => {
                 resolve({ task, logId });
-                await this.restic.unlockAll(endpoint, key);
-                await this.runForgetAndPrune(endpoint, key, policy, log, signal);
+                try {
+                    const taskSignal = this.tasks.startTask(id, enum_1.TaskType.Forget, logId, signal);
+                    await this.restic.unlockAll(endpoint, key);
+                    await this.runForgetAndPrune(endpoint, key, policy, log, taskSignal);
+                }
+                finally {
+                    this.tasks.endTask(id);
+                }
             }, (error) => {
                 void this.updateLocalMetrics(id, {
                     resticParameters: { endpoint, key },
                 });
+                this.telemetry.submitStructuredLog('Finished repository prune', {
+                    repositoryId: id,
+                    error,
+                });
                 if (error) {
                     fail(error);
                 }
@@ -435,7 +498,7 @@ let RepositoryService = class RepositoryService {
         });
     }
     async checkImportRepository(id, backendId) {
-        const { endpoint, key } = await this.getResticParameters(id, backendId);
+        const { endpoint, key } = await this.getResticParameters({ backendId, remoteId: id });
         try {
             await this.restic.snapshots(endpoint, key);
             return {
@@ -449,31 +512,84 @@ let RepositoryService = class RepositoryService {
         }
     }
     async importRepository(id, backendId) {
-        const { configuration } = await this.backend.getBackend(backendId);
-        const backend = backend_1.Backend.from(configuration, this.moduleConfig.get());
-        const { repository: remote } = await backend.getRepository(id);
-        const endpoint = await backend.getResticEndpoint(remote.id);
-        const key = await this.config.deriveEncryptionKey(`repository-${remote.id}`);
-        await this.restic.keyList(endpoint, key);
-        let paths = [];
+        this.telemetry.submitStructuredLog('Running repository import', {
+            repositoryId: id,
+            backendId,
+        });
         try {
-            const snapshots = await this.restic.snapshots(endpoint, key);
-            snapshots.sort((a, b) => +b.time - +a.time);
-            paths = snapshots[0].paths;
+            const { configuration, backend } = await this.backend.getBackend(backendId);
+            const { repository: remote } = await backend.getRepository(id);
+            const localId = (0, node_crypto_1.randomUUID)();
+            const endpoint = await backend.getResticEndpoint(remote.id);
+            const key = await this.config.deriveEncryptionKey(`repository-${remote.id}`);
+            await this.restic.keyList(endpoint, key);
+            let paths = [];
+            try {
+                const snapshots = await this.restic.snapshots(endpoint, key);
+                snapshots.sort((a, b) => +b.time - +a.time);
+                paths = snapshots[0].paths;
+            }
+            catch {
+            }
+            await this.repository.create({
+                id: localId,
+                remoteId: remote.id,
+                backendId,
+                retentionPolicy: restic_1.DEFAULT_RETENTION_POLICY,
+            });
+            const repository = {
+                ...(await this.getLocalRepository(localId, { paths, retentionPolicy: restic_1.DEFAULT_RETENTION_POLICY })),
+                ...remote,
+                id: localId,
+                backends: {
+                    primary: {
+                        id: backendId,
+                        online: true,
+                        type: configuration.type,
+                    },
+                    secondary: [],
+                },
+            };
+            this.telemetry.submitStructuredLog('Finished repository import', {
+                repositoryId: id,
+                backendId,
+            });
+            this.events.publish({
+                type: 'RepositoryCreate',
+                repository,
+            });
+            return {
+                repository,
+            };
         }
-        catch {
+        catch (error) {
+            this.telemetry.submitStructuredLog('Finished repository import', {
+                repositoryId: id,
+                backendId,
+                error,
+            });
+            throw error;
         }
-        await this.repository.create({
-            id: remote.id,
-            backendId,
-            retentionPolicy: restic_1.DEFAULT_RETENTION_POLICY,
+    }
+    async reconfigureRepositoryPrimaryBackend(id, dto) {
+        const { backend, configuration } = await this.backend.getBackend(dto.backendId);
+        const { repository: remote } = await backend.createRepository({
+            name: 'Restored Repository',
+            worm: false,
         });
-        const repository = {
-            ...(await this.getLocalRepository(id, { paths, retentionPolicy: restic_1.DEFAULT_RETENTION_POLICY })),
+        const endpoint = await backend.getResticEndpoint(remote.id);
+        const key = await this.config.deriveEncryptionKey(`repository-${remote.id}`);
+        await this.restic.init(endpoint, key);
+        await this.repository.update(id, {
+            remoteId: remote.id,
+            backendId: dto.backendId,
+        });
+        const { id: _, ...repository } = {
+            ...(await this.getLocalRepository(id)),
             ...remote,
             backends: {
                 primary: {
-                    id: backendId,
+                    id: dto.backendId,
                     online: true,
                     type: configuration.type,
                 },
@@ -481,11 +597,15 @@ let RepositoryService = class RepositoryService {
             },
         };
         this.events.publish({
-            type: 'RepositoryCreate',
+            type: 'RepositoryUpdate',
+            repositoryId: id,
             repository,
         });
         return {
-            repository,
+            repository: {
+                id,
+                ...repository,
+            },
         };
     }
     async getSnapshots(id) {
@@ -496,7 +616,12 @@ let RepositoryService = class RepositoryService {
         };
     }
     async restoreSnapshot(id, snapshotId, dto) {
+        this.telemetry.submitStructuredLog('Running repository snapshot restore', {
+            repositoryId: id,
+            snapshotId,
+        });
         return new Promise((resolve) => {
+            let summary;
             const task = new Promise((complete, fail) => void this.runHistory.createLog(id, enum_1.TaskType.Restore, async (log, logId) => {
                 resolve({
                     task,
@@ -505,12 +630,18 @@ let RepositoryService = class RepositoryService {
                 const { endpoint, key } = await this.getResticParameters(id);
                 try {
                     const signal = this.tasks.startTask(id, enum_1.TaskType.Restore, logId);
-                    await this.restic.restore(endpoint, key, snapshotId, dto, log, signal);
+                    summary = await this.restic.restore(endpoint, key, snapshotId, dto, log, signal);
                 }
                 finally {
                     this.tasks.endTask(id);
                 }
             }, (error) => {
+                this.telemetry.submitStructuredLog('Finished repository snapshot restore', {
+                    repositoryId: id,
+                    snapshotId,
+                    summary,
+                    error,
+                });
                 if (error) {
                     fail(error);
                 }
@@ -522,16 +653,21 @@ let RepositoryService = class RepositoryService {
         });
     }
     async restoreFromPoint(id, snapshotId, backendId, dto) {
+        this.telemetry.submitStructuredLog('Running repository restore from point', {
+            repositoryId: id,
+            snapshotId,
+        });
         return new Promise((resolve) => {
+            let summary;
             const task = new Promise((complete, fail) => void this.runHistory.createEphemeralLog(async (log, logId) => {
                 resolve({
                     task,
                     logId,
                 });
-                const { endpoint, key } = await this.getResticParameters(id, backendId);
+                const { endpoint, key } = await this.getResticParameters({ backendId, remoteId: id });
                 try {
                     const signal = this.tasks.startTask(id, enum_1.TaskType.Restore, logId);
-                    await this.restic.restore(endpoint, key, snapshotId, { include: dto.include }, log, signal);
+                    summary = await this.restic.restore(endpoint, key, snapshotId, { include: dto.include }, log, signal);
                     if (dto.yuccaConfig) {
                         const target = await this.storage.tempdir();
                         await this.restic.restore(endpoint, key, snapshotId, { include: [dto.yuccaConfig], target }, log, signal);
@@ -549,6 +685,12 @@ let RepositoryService = class RepositoryService {
                     this.tasks.endTask(id);
                 }
             }, (error) => {
+                this.telemetry.submitStructuredLog('Finished repository restore from point', {
+                    repositoryId: id,
+                    snapshotId,
+                    summary,
+                    error,
+                });
                 if (error) {
                     fail(error);
                 }
@@ -561,36 +703,66 @@ let RepositoryService = class RepositoryService {
     }
     async forgetSnapshot(id, snapshotId) {
         if (!this.tasks.canStart(id)) {
+            this.telemetry.submitStructuredLog('Repository snapshot forget rejected, task already running', {
+                repositoryId: id,
+                snapshotId,
+            });
             throw new common_1.BadRequestException('Task already running!');
         }
+        this.telemetry.submitStructuredLog('Running repository snapshot forget', {
+            repositoryId: id,
+            snapshotId,
+        });
         const { endpoint, key } = await this.getResticParameters(id);
+        let error;
         try {
             const signal = this.tasks.startTask(id, enum_1.TaskType.Forget);
             await this.restic.unlockAll(endpoint, key);
             await this.restic.forget(endpoint, key, snapshotId, true, signal);
         }
+        catch (error_) {
+            error = error_;
+        }
         finally {
             this.tasks.endTask(id);
         }
+        this.telemetry.submitStructuredLog('Finished repository snapshot forget', {
+            repositoryId: id,
+            snapshotId,
+            error,
+        });
+        if (error) {
+            throw error;
+        }
         await this.updateLocalMetrics(id, {
             resticParameters: { endpoint, key },
         });
     }
     async getSnapshotListing(id, snapshotId, dto) {
         const path = dto.path ?? '/';
-        const { endpoint, key } = await this.getResticParameters(id);
-        const files = await this.restic.ls(endpoint, key, snapshotId, path);
-        return {
-            parent: (0, node_path_1.dirname)(path),
-            path,
-            items: files
-                .filter((file) => file.message_type === 'node')
-                .filter((file) => file.path !== path)
-                .map((file) => ({
-                path: file.path,
-                isDirectory: file.type === 'dir',
-            })),
-        };
+        try {
+            const { endpoint, key } = await this.getResticParameters(id);
+            const files = await this.restic.ls(endpoint, key, snapshotId, path);
+            return {
+                parent: (0, node_path_1.dirname)(path),
+                path,
+                items: files
+                    .filter((file) => file.message_type === 'node')
+                    .filter((file) => file.path !== path)
+                    .map((file) => ({
+                    path: file.path,
+                    isDirectory: file.type === 'dir',
+                })),
+            };
+        }
+        catch (error) {
+            this.telemetry.submitStructuredLog('Failed to get repository snapshot listing', {
+                repositoryId: id,
+                snapshotId,
+                error,
+            });
+            throw error;
+        }
     }
     async getRunHistory(id) {
         const runs = await this.runHistory.getAll(id);
@@ -618,6 +790,7 @@ exports.RepositoryService = RepositoryService = __decorate([
         repositoryLocalMetrics_repository_1.RepositoryLocalMetricsRepository,
         moduleConfig_repository_1.ModuleConfigRepository,
         storage_repository_1.StorageRepository,
-        bootstrap_service_1.BootstrapService])
+        bootstrap_service_1.BootstrapService,
+        telemetry_service_1.TelemetryService])
 ], RepositoryService);
 //# sourceMappingURL=repository.service.js.map