@protontech/drive-sdk 0.1.2 → 0.2.0

package/src/internal/nodes/extendedAttributes.test.ts

@@ -83,83 +83,100 @@ describe('extended attrbiutes', () => {
     });
 
     describe('should parses file attributes', () => {
-        const testCases: [string, FileExtendedAttributesParsed][] = [
-            ['', {}],
-            ['{}', {}],
-            ['a', {}],
+        const testCases: [Date, string, FileExtendedAttributesParsed][] = [
+            [new Date('2025-01-01'), '', {}],
+            [new Date('2025-01-01'), '{}', {}],
+            [new Date('2025-01-01'), 'a', {}],
             [
+                new Date('2025-01-01'),
                 '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000"}}',
                 {
                     claimedModificationTime: new Date(1234567890000),
                     claimedSize: undefined,
                     claimedDigests: undefined,
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: undefined,
                 },
             ],
             [
+                new Date('2025-01-01'),
                 '{"Common": {"Size": 123}}',
                 {
                     claimedModificationTime: undefined,
                     claimedSize: 123,
                     claimedDigests: undefined,
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: undefined,
                 },
             ],
             [
-                '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": 123, "BlockSizes": [1, 2, 3]}}',
+                new Date('2025-01-01'),
+                '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": 123, "BlockSizes": [123]}}',
                 {
                     claimedModificationTime: new Date(1234567890000),
                     claimedSize: 123,
                     claimedDigests: undefined,
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: [123],
                 },
             ],
             [
+                new Date('2025-01-01'),
                 '{"Common": {"ModificationTime": "aa", "Size": 123}}',
                 {
                     claimedModificationTime: undefined,
                     claimedSize: 123,
                     claimedDigests: undefined,
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: undefined,
                 },
             ],
             [
+                new Date('2025-01-01'),
                 '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": "aaa"}}',
                 {
                     claimedModificationTime: new Date(1234567890000),
                     claimedSize: undefined,
                     claimedDigests: undefined,
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: undefined,
                 },
             ],
             [
+                new Date('2025-01-01'),
                 '{"Common": {"Digests": {}}}',
                 {
                     claimedModificationTime: undefined,
                     claimedSize: undefined,
                     claimedDigests: undefined,
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: undefined,
                 },
             ],
             [
+                new Date('2025-01-01'),
                 '{"Common": {"Digests": {"SHA1": null}}}',
                 {
                     claimedModificationTime: undefined,
                     claimedSize: undefined,
                     claimedDigests: undefined,
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: undefined,
                 },
             ],
             [
+                new Date('2025-01-01'),
                 '{"Common": {"Digests": {"SHA1": "abcdef"}}}',
                 {
                     claimedModificationTime: undefined,
                     claimedSize: undefined,
                     claimedDigests: { sha1: 'abcdef' },
                     claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: undefined,
                 },
             ],
             [
+                new Date('2025-01-01'),
                 '{"Common": {}, "Media": {}}',
                 {
                     claimedModificationTime: undefined,
@@ -168,12 +185,48 @@ describe('extended attrbiutes', () => {
                     claimedAdditionalMetadata: {
                         Media: {},
                     },
+                    claimedBlockSizes: undefined,
+                },
+            ],
+            [
+                new Date('2025-01-01'),
+                '{"Common": {"BlockSizes": [1024, 1024, 1024, 1024, 123]}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: [1024, 1024, 1024, 1024, 123],
+                },
+            ],
+            [
+                // Starting from 2025-01-01, block sizes are passed as is.
+                new Date('2025-01-01'),
+                '{"Common": {"BlockSizes": [1024, 1024, 123, 1024, 1024]}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: [1024, 1024, 123, 1024, 1024],
+                },
+            ],
+            [
+                // Before 2025-01-01, block sizes are sorted in descending order.
+                new Date('2024-01-01'),
+                '{"Common": {"BlockSizes": [123, 1024, 1024, 1024, 1024]}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                    claimedBlockSizes: [1024, 1024, 1024, 1024, 123],
                 },
             ],
         ];
-        testCases.forEach(([input, expectedAttributes]) => {
+        testCases.forEach(([creationTime, input, expectedAttributes]) => {
             it(`should parse ${input}`, () => {
-                const output = parseFileExtendedAttributes(getMockLogger(), input);
+                const output = parseFileExtendedAttributes(getMockLogger(), creationTime, input);
                 expect(output).toMatchObject(expectedAttributes);
             });
         });

package/src/internal/nodes/extendedAttributes.ts

@@ -48,6 +48,7 @@ export interface FileExtendedAttributesParsed {
         sha1?: string;
     };
     claimedAdditionalMetadata?: object;
+    claimedBlockSizes?: number[];
 }
 
 export function generateFolderExtendedAttributes(claimedModificationTime?: Date): string | undefined {
@@ -113,7 +114,11 @@ export function generateFileExtendedAttributes(options: {
     });
 }
 
-export function parseFileExtendedAttributes(logger: Logger, extendedAttributes?: string): FileExtendedAttributesParsed {
+export function parseFileExtendedAttributes(
+    logger: Logger,
+    creationTime: Date,
+    extendedAttributes?: string,
+): FileExtendedAttributesParsed {
     if (!extendedAttributes) {
         return {};
     }
@@ -131,6 +136,7 @@ export function parseFileExtendedAttributes(logger: Logger, extendedAttributes?:
             claimedAdditionalMetadata: Object.keys(claimedAdditionalMetadata).length
                 ? claimedAdditionalMetadata
                 : undefined,
+            claimedBlockSizes: parseBlockSizes(logger, creationTime, parsed),
         };
     } catch (error: unknown) {
         logger.error(`Failed to parse extended attributes`, error);
@@ -183,3 +189,33 @@ function parseDigests(logger: Logger, xattr?: FileExtendedAttributesSchema): { s
         sha1,
     };
 }
+
+function parseBlockSizes(
+    logger: Logger,
+    creationTime: Date,
+    xattr?: FileExtendedAttributesSchema,
+): number[] | undefined {
+    const blockSizes = xattr?.Common?.BlockSizes;
+    if (blockSizes === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(blockSizes)) {
+        logger.warn(`XAttr block sizes "${blockSizes}" is not valid`);
+        return undefined;
+    }
+    if (blockSizes.some((size) => typeof size !== 'number' || size <= 0)) {
+        logger.warn(`XAttr block sizes "${blockSizes}" is not valid`);
+        return undefined;
+    }
+    if (blockSizes.length === 0) {
+        return undefined;
+    }
+    // Before 2025, there was a bug on the Windows client that didn't sort
+    // the block sizes in correct order. Because the sizes were all the same
+    // except the last one, which was always smaller, the block sizes must be
+    // sorted in descending order.
+    if (creationTime < new Date('2025-01-01')) {
+        return blockSizes.sort((a, b) => b - a);
+    }
+    return blockSizes;
+}

package/src/internal/nodes/index.test.ts

@@ -20,7 +20,7 @@ function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<
     return {
         uid,
         parentUid,
-        directMemberRole: MemberRole.Admin,
+        directRole: MemberRole.Admin,
         type: NodeType.File,
         mediaType: 'text',
         isShared: false,

package/src/internal/nodes/interface.ts

@@ -32,7 +32,12 @@ interface BaseNode {
     // Share node metadata
     shareId?: string;
     isShared: boolean;
-    directMemberRole: MemberRole;
+    directRole: MemberRole;
+    membership?: {
+        role: MemberRole;
+        inviteTime: Date;
+        // TODO: acceptedBy: Author;
+    };
 }
 
 /**
@@ -50,6 +55,12 @@ export interface EncryptedNodeCrypto {
     armoredKey: string;
     armoredNodePassphrase: string;
     armoredNodePassphraseSignature: string;
+    membership?: {
+        inviterEmail: string;
+        base64MemberSharePassphraseKeyPacket: string;
+        armoredInviterSharePassphraseKeyPacketSignature: string;
+        armoredInviteeSharePassphraseSessionKeySignature: string;
+    };
 }
 
 export interface EncryptedNodeFileCrypto extends EncryptedNodeCrypto {
@@ -78,9 +89,14 @@ export interface EncryptedNodeAlbumCrypto extends EncryptedNodeCrypto {}
  * This interface is holding decrypted node metadata that is not yet parsed,
  * such as extended attributes.
  */
-export interface DecryptedUnparsedNode extends BaseNode {
+export interface DecryptedUnparsedNode extends Omit<BaseNode, 'membership'> {
     keyAuthor: Author;
     nameAuthor: Author;
+    membership?: {
+        role: MemberRole;
+        inviteTime: Date;
+        sharedBy: Author;
+    };
     name: Result<string, Error>;
     activeRevision?: Result<DecryptedUnparsedRevision, Error>;
     folder?: {
@@ -147,6 +163,7 @@ export interface DecryptedUnparsedRevision extends BaseRevision {
 
 export interface DecryptedRevision extends Revision {
     thumbnails?: Thumbnail[];
+    claimedBlockSizes?: number[];
 }
 
 /**

package/src/internal/nodes/nodesAccess.ts

@@ -270,6 +270,16 @@ export class NodesAccess {
                             claimedAuthor: encryptedNode.encryptedCrypto.nameSignatureEmail,
                             error: getErrorMessage(error),
                         }),
+                        membership: encryptedNode.membership
+                            ? {
+                                  role: encryptedNode.membership.role,
+                                  inviteTime: encryptedNode.membership.inviteTime,
+                                  sharedBy: resultError({
+                                      claimedAuthor: encryptedNode.encryptedCrypto.membership?.inviterEmail,
+                                      error: getErrorMessage(error),
+                                  }),
+                              }
+                            : undefined,
                         errors: [error],
                         treeEventScopeId: splitNodeUid(encryptedNode.uid).volumeId,
                     },
@@ -311,7 +321,11 @@ export class NodesAccess {
 
         if (unparsedNode.type === NodeType.File) {
             const extendedAttributes = unparsedNode.activeRevision?.ok
-                ? parseFileExtendedAttributes(this.logger, unparsedNode.activeRevision.value.extendedAttributes)
+                ? parseFileExtendedAttributes(
+                      this.logger,
+                      unparsedNode.activeRevision.value.creationTime,
+                      unparsedNode.activeRevision.value.extendedAttributes,
+                  )
                 : undefined;
 
             return {

package/src/internal/nodes/nodesManagement.ts

@@ -245,7 +245,7 @@ export class NodesManagement {
 
             // Share node metadata
             isShared: false,
-            directMemberRole: MemberRole.Inherited,
+            directRole: MemberRole.Inherited,
 
             // Decrypted metadata
             isStale: false,

package/src/internal/nodes/nodesRevisions.ts

@@ -1,9 +1,10 @@
-import { Logger, Revision } from '../../interface';
+import { Logger } from '../../interface';
 import { makeNodeUidFromRevisionUid } from '../uids';
 import { NodeAPIService } from './apiService';
 import { NodesCryptoService } from './cryptoService';
 import { NodesAccess } from './nodesAccess';
 import { parseFileExtendedAttributes } from './extendedAttributes';
+import { DecryptedRevision } from './interface';
 
 /**
  * Provides access to revisions metadata.
@@ -21,26 +22,34 @@ export class NodesRevisons {
         this.nodesAccess = nodesAccess;
     }
 
-    async getRevision(nodeRevisionUid: string): Promise<Revision> {
+    async getRevision(nodeRevisionUid: string): Promise<DecryptedRevision> {
         const nodeUid = makeNodeUidFromRevisionUid(nodeRevisionUid);
         const { key } = await this.nodesAccess.getNodeKeys(nodeUid);
 
         const encryptedRevision = await this.apiService.getRevision(nodeRevisionUid);
         const revision = await this.cryptoService.decryptRevision(nodeUid, encryptedRevision, key);
-        const extendedAttributes = parseFileExtendedAttributes(this.logger, revision.extendedAttributes);
+        const extendedAttributes = parseFileExtendedAttributes(
+            this.logger,
+            revision.creationTime,
+            revision.extendedAttributes,
+        );
         return {
             ...revision,
             ...extendedAttributes,
         };
     }
 
-    async *iterateRevisions(nodeUid: string, signal?: AbortSignal): AsyncGenerator<Revision> {
+    async *iterateRevisions(nodeUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedRevision> {
         const { key } = await this.nodesAccess.getNodeKeys(nodeUid);
 
         const encryptedRevisions = await this.apiService.getRevisions(nodeUid, signal);
         for (const encryptedRevision of encryptedRevisions) {
             const revision = await this.cryptoService.decryptRevision(nodeUid, encryptedRevision, key);
-            const extendedAttributes = parseFileExtendedAttributes(this.logger, revision.extendedAttributes);
+            const extendedAttributes = parseFileExtendedAttributes(
+                this.logger,
+                revision.creationTime,
+                revision.extendedAttributes,
+            );
             yield {
                 ...revision,
                 ...extendedAttributes,

package/src/internal/shares/cryptoService.test.ts

@@ -59,7 +59,7 @@ describe('SharesCryptoService', () => {
 
         expect(account.getOwnAddress).toHaveBeenCalledWith('addressId');
         expect(account.getPublicKeys).toHaveBeenCalledWith('signatureEmail');
-        expect(telemetry.logEvent).not.toHaveBeenCalled();
+        expect(telemetry.recordMetric).not.toHaveBeenCalled();
     });
 
     it('should decrypt root share with signiture verification error', async () => {
@@ -97,12 +97,13 @@ describe('SharesCryptoService', () => {
 
         expect(account.getOwnAddress).toHaveBeenCalledWith('addressId');
         expect(account.getPublicKeys).toHaveBeenCalledWith('signatureEmail');
-        expect(telemetry.logEvent).toHaveBeenCalledWith({
+        expect(telemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'verificationError',
             volumeType: 'own_volume',
             field: 'shareKey',
             addressMatchingDefaultShare: undefined,
             fromBefore2024: undefined,
+            uid: 'shareId',
         });
     });
 
@@ -124,12 +125,13 @@ describe('SharesCryptoService', () => {
 
         await expect(result).rejects.toThrow(error);
 
-        expect(telemetry.logEvent).toHaveBeenCalledWith({
+        expect(telemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'decryptionError',
             volumeType: 'own_volume',
             field: 'shareKey',
             fromBefore2024: undefined,
             error,
+            uid: 'shareId',
         });
     });
 });

package/src/internal/shares/cryptoService.ts

@@ -76,7 +76,7 @@ export class SharesCryptoService {
         const { keys: addressKeys } = await this.account.getOwnAddress(share.addressId);
         const addressPublicKeys = await this.account.getPublicKeys(share.creatorEmail);
 
-        let key, passphraseSessionKey, verified;
+        let key, passphraseSessionKey, verified, verificationErrors;
         try {
             const result = await this.driveCrypto.decryptKey(
                 share.encryptedCrypto.armoredKey,
@@ -88,6 +88,7 @@ export class SharesCryptoService {
             key = result.key;
             passphraseSessionKey = result.passphraseSessionKey;
             verified = result.verified;
+            verificationErrors = result.verificationErrors;
         } catch (error: unknown) {
             this.reportDecryptionError(share, error);
             throw error;
@@ -98,7 +99,7 @@ export class SharesCryptoService {
                 ? resultOk(share.creatorEmail)
                 : resultError({
                       claimedAuthor: share.creatorEmail,
-                      error: getVerificationMessage(verified),
+                      error: getVerificationMessage(verified, verificationErrors),
                   });
 
         if (!author.ok) {
@@ -125,12 +126,13 @@ export class SharesCryptoService {
         const fromBefore2024 = share.creationTime ? share.creationTime < new Date('2024-01-01') : undefined;
         this.logger.error(`Failed to decrypt share ${share.shareId} (from before 2024: ${fromBefore2024})`, error);
 
-        this.telemetry.logEvent({
+        this.telemetry.recordMetric({
             eventName: 'decryptionError',
             volumeType: shareTypeToMetricContext(share.type),
             field: 'shareKey',
             fromBefore2024,
             error,
+            uid: share.shareId,
         });
         this.reportedDecryptionErrors.add(share.shareId);
     }
@@ -143,11 +145,12 @@ export class SharesCryptoService {
         const fromBefore2024 = share.creationTime ? share.creationTime < new Date('2024-01-01') : undefined;
         this.logger.error(`Failed to verify share ${share.shareId} (from before 2024: ${fromBefore2024})`);
 
-        this.telemetry.logEvent({
+        this.telemetry.recordMetric({
             eventName: 'verificationError',
             volumeType: shareTypeToMetricContext(share.type),
             field: 'shareKey',
             fromBefore2024,
+            uid: share.shareId,
         });
         this.reportedVerificationErrors.add(share.shareId);
     }

package/src/internal/sharing/apiService.ts

@@ -4,7 +4,7 @@ import {
     DriveAPIService,
     drivePaths,
     nodeTypeNumberToNodeType,
-    permissionsToDirectMemberRole,
+    permissionsToMemberRole,
     memberRoleToPermission,
 } from '../apiService';
 import {
@@ -224,7 +224,7 @@ export class SharingAPIService {
             base64KeyPacket: response.Invitation.KeyPacket,
             base64KeyPacketSignature: response.Invitation.KeyPacketSignature,
             invitationTime: new Date(response.Invitation.CreateTime * 1000),
-            role: permissionsToDirectMemberRole(this.logger, response.Invitation.Permissions),
+            role: permissionsToMemberRole(this.logger, response.Invitation.Permissions),
             share: {
                 armoredKey: response.Share.ShareKey,
                 armoredPassphrase: response.Share.Passphrase,
@@ -312,7 +312,7 @@ export class SharingAPIService {
                 base64KeyPacket: member.KeyPacket,
                 base64KeyPacketSignature: member.KeyPacketSignature,
                 invitationTime: new Date(member.CreateTime * 1000),
-                role: permissionsToDirectMemberRole(this.logger, member.Permissions),
+                role: permissionsToMemberRole(this.logger, member.Permissions),
             };
         });
     }
@@ -469,7 +469,7 @@ export class SharingAPIService {
             uid: makePublicLinkUid(shareUrl.ShareID, shareUrl.ShareURLID),
             creationTime: new Date(shareUrl.CreateTime * 1000),
             expirationTime: shareUrl.ExpirationTime ? new Date(shareUrl.ExpirationTime * 1000) : undefined,
-            role: permissionsToDirectMemberRole(this.logger, shareUrl.Permissions),
+            role: permissionsToMemberRole(this.logger, shareUrl.Permissions),
             flags: shareUrl.Flags,
             creatorEmail: shareUrl.CreatorEmail,
             publicUrl: shareUrl.PublicUrl,
@@ -588,7 +588,7 @@ export class SharingAPIService {
             addedByEmail: invitation.InviterEmail,
             inviteeEmail: invitation.InviteeEmail,
             invitationTime: new Date(invitation.CreateTime * 1000),
-            role: permissionsToDirectMemberRole(this.logger, invitation.Permissions),
+            role: permissionsToMemberRole(this.logger, invitation.Permissions),
             base64KeyPacket: invitation.KeyPacket,
             base64KeyPacketSignature: invitation.KeyPacketSignature,
         };
@@ -605,7 +605,7 @@ export class SharingAPIService {
             addedByEmail: invitation.InviterEmail,
             inviteeEmail: invitation.InviteeEmail,
             invitationTime: new Date(invitation.CreateTime * 1000),
-            role: permissionsToDirectMemberRole(this.logger, invitation.Permissions),
+            role: permissionsToMemberRole(this.logger, invitation.Permissions),
             base64Signature: invitation.ExternalInvitationSignature,
             state,
         };

package/src/internal/sharing/cryptoService.test.ts

@@ -84,7 +84,7 @@ describe('SharingCryptoService', () => {
                 'armoredPassphrase',
             );
             expect(driveCrypto.decryptNodeName).toHaveBeenCalledWith('encryptedName', 'decryptedKey', []);
-            expect(telemetry.logEvent).not.toHaveBeenCalled();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('should handle undecryptable URL password', async () => {
@@ -97,11 +97,12 @@ describe('SharingCryptoService', () => {
                 url: resultError(new Error('Failed to decrypt bookmark password: Failed to decrypt URL password')),
                 nodeName: resultError(new Error('Failed to decrypt bookmark password: Failed to decrypt URL password')),
             });
-            expect(telemetry.logEvent).toHaveBeenCalledWith({
+            expect(telemetry.recordMetric).toHaveBeenCalledWith({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'shareUrlPassword',
                 error,
+                uid: 'tokenId',
             });
         });
 
@@ -115,11 +116,12 @@ describe('SharingCryptoService', () => {
                 url: resultOk('https://drive.proton.me/urls/tokenId#urlPassword'),
                 nodeName: resultError(new Error('Failed to decrypt bookmark key: Failed to decrypt share key')),
             });
-            expect(telemetry.logEvent).toHaveBeenCalledWith({
+            expect(telemetry.recordMetric).toHaveBeenCalledWith({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'shareKey',
                 error,
+                uid: 'tokenId',
             });
         });
 
@@ -133,11 +135,12 @@ describe('SharingCryptoService', () => {
                 url: resultOk('https://drive.proton.me/urls/tokenId#urlPassword'),
                 nodeName: resultError(new Error('Failed to decrypt bookmark name: Failed to decrypt node name')),
             });
-            expect(telemetry.logEvent).toHaveBeenCalledWith({
+            expect(telemetry.recordMetric).toHaveBeenCalledWith({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'nodeName',
                 error,
+                uid: 'tokenId',
             });
         });
 

package/src/internal/sharing/cryptoService.ts

@@ -148,7 +148,7 @@ export class SharingCryptoService {
         }
         const addressPublicKeys = await this.account.getPublicKeys(share.creatorEmail);
 
-        const { key, passphraseSessionKey, verified } = await this.driveCrypto.decryptKey(
+        const { key, passphraseSessionKey, verified, verificationErrors } = await this.driveCrypto.decryptKey(
             share.encryptedCrypto.armoredKey,
             share.encryptedCrypto.armoredPassphrase,
             share.encryptedCrypto.armoredPassphraseSignature,
@@ -161,7 +161,7 @@ export class SharingCryptoService {
                 ? resultOk(share.creatorEmail)
                 : resultError({
                       claimedAuthor: share.creatorEmail,
-                      error: getVerificationMessage(verified),
+                      error: getVerificationMessage(verified, verificationErrors),
                   });
 
         return {
@@ -478,11 +478,12 @@ export class SharingCryptoService {
 
             return urlPassword;
         } catch (error: unknown) {
-            this.telemetry.logEvent({
+            this.telemetry.recordMetric({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'shareUrlPassword',
                 error,
+                uid: encryptedBookmark.tokenId,
             });
 
             const message = getErrorMessage(error);
@@ -503,11 +504,12 @@ export class SharingCryptoService {
 
             return shareKey;
         } catch (error: unknown) {
-            this.telemetry.logEvent({
+            this.telemetry.recordMetric({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'shareKey',
                 error,
+                uid: encryptedBookmark.tokenId,
             });
 
             const message = getErrorMessage(error);
@@ -535,11 +537,12 @@ export class SharingCryptoService {
 
             return resultOk(name);
         } catch (error: unknown) {
-            this.telemetry.logEvent({
+            this.telemetry.recordMetric({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'nodeName',
                 error,
+                uid: encryptedBookmark.tokenId,
             });
 
             const message = getErrorMessage(error);