chore: improve monitoring for fix: use applicationUniversalIdentifier in deleteB

Changed the error logging in `FilesFieldDeletionJob` from `logger.log` (info level) to `logger.error` with full stack trace.

Previously, when file deletion failed in the background job, the error was silently swallowed with an info-level log message (`this.logger.log('Failed to delete file ...')`), making it invisible in production monitoring. The caught error object was also discarded entirely, losing the stack trace and root cause details.

Now the job logs at error level with the workspace ID for context and includes the full stack trace, making file deletion failures detectable by log-based alerting (Sentry, Datadog, etc.).

packages/twenty-server/src/engine/core-modules/file-storage/__tests__/file-storage.service.spec.ts

@@ -16,6 +16,8 @@ describe('FileStorageService', () => {
 
   const mockFileRepository = {
     save: jest.fn(),
+    findOneOrFail: jest.fn(),
+    delete: jest.fn(),
   };
 
   const mockApplicationRepository = {
@@ -193,6 +195,51 @@ describe('FileStorageService', () => {
       });
     });
 
+    describe('deleteByFileId', () => {
+      it('should build the correct storage path using applicationUniversalIdentifier', async () => {
+        const fileId = 'file-uuid';
+        const workspaceId = 'ws-uuid';
+        const applicationId = 'app-uuid';
+        const applicationUniversalIdentifier = 'twenty-standard';
+
+        mockFileRepository.findOneOrFail.mockResolvedValue({
+          id: fileId,
+          workspaceId,
+          applicationId,
+          path: 'files-field/field-uid/file-uuid.pdf',
+        });
+
+        mockApplicationRepository.findOneOrFail.mockResolvedValue({
+          id: applicationId,
+          universalIdentifier: applicationUniversalIdentifier,
+          workspaceId,
+        });
+
+        mockDriver.delete.mockResolvedValue(undefined);
+        mockFileRepository.delete.mockResolvedValue(undefined);
+
+        await service.deleteByFileId({
+          fileId,
+          workspaceId,
+          fileFolder: 'files-field' as any,
+        });
+
+        expect(mockApplicationRepository.findOneOrFail).toHaveBeenCalledWith({
+          where: {
+            id: applicationId,
+            workspaceId,
+          },
+        });
+
+        expect(mockDriver.delete).toHaveBeenCalledWith({
+          folderPath: `${workspaceId}/${applicationUniversalIdentifier}/files-field/field-uid`,
+          filename: 'file-uuid.pdf',
+        });
+
+        expect(mockFileRepository.delete).toHaveBeenCalledWith(fileId);
+      });
+    });
+
     describe('checkFolderExistsLegacy', () => {
       it('should delegate to the current driver and return true', async () => {
         const checkParams = {

packages/twenty-server/src/engine/core-modules/file-storage/file-storage.service.ts

@@ -224,11 +224,28 @@ export class FileStorageService {
         path: Like(`${fileFolder}/%`),
       },
     });
+
+    const application = await this.applicationRepository.findOneOrFail({
+      where: {
+        id: file.applicationId,
+        workspaceId,
+      },
+    });
+
+    const resourcePath = file.path.replace(`${fileFolder}/`, '');
+
+    const onStoragePath = this.buildOnStoragePath({
+      workspaceId,
+      applicationUniversalIdentifier: application.universalIdentifier,
+      fileFolder,
+      resourcePath,
+    });
+
     const driver = this.fileStorageDriverFactory.getCurrentDriver();
 
     await driver.delete({
-      folderPath: `${file.workspaceId}/${file.applicationId}`,
-      filename: file.path,
+      folderPath: dirname(onStoragePath),
+      filename: basename(onStoragePath),
     });
 
     await this.fileRepository.delete(fileId);

packages/twenty-server/src/engine/core-modules/file/files-field/jobs/files-field-deletion.job.ts

@@ -32,8 +32,11 @@ export class FilesFieldDeletionJob {
           fileId,
           workspaceId,
         });
-      } catch {
-        this.logger.log(`Failed to delete file ${fileId}`);
+      } catch (error) {
+        this.logger.error(
+          `Failed to delete file ${fileId} in workspace ${workspaceId}`,
+          error instanceof Error ? error.stack : String(error),
+        );
       }
     }
   }