From f9155fa959e9bbb369d081736c9999ca315c043f Mon Sep 17 00:00:00 2001
From: Steve Freeman <sfreeman422@protonmail.com>
Date: Sun, 22 Mar 2026 12:04:43 -0400
Subject: [PATCH] Improved logging + DOCKERFILE changes

---
 README.md                                     |  27 ++++
 packages/backend/Dockerfile                   |   9 +-
 packages/backend/src/ai/ai.controller.ts      |  22 +++-
 packages/backend/src/ai/ai.service.spec.ts    |  30 +++++
 packages/backend/src/ai/ai.service.ts         | 104 +++++++++++----
 .../ai/memory/memory.persistence.service.ts   |  16 ++-
 .../backfire/backfire.persistence.service.ts  |  11 ++
 .../backend/src/backfire/backfire.service.ts  |   9 +-
 packages/backend/src/clap/clap.controller.ts  |  11 +-
 packages/backend/src/clap/clap.service.ts     |   4 +-
 .../src/confession/confession.controller.ts   |  11 +-
 .../src/confession/confession.service.spec.ts |   8 +-
 .../src/confession/confession.service.ts      |  10 +-
 .../backend/src/counter/counter.controller.ts |   6 +-
 .../counter/counter.persistence.service.ts    |  23 +++-
 .../backend/src/counter/counter.service.ts    |  18 ++-
 .../backend/src/define/define.controller.ts   |   7 +-
 packages/backend/src/define/define.service.ts |  17 ++-
 .../backend/src/event/event.controller.ts     |   8 +-
 .../src/event/event.persistence.service.ts    |  25 +++-
 .../backend/src/event/event.service.spec.ts   |  13 +-
 packages/backend/src/event/event.service.ts   |   8 +-
 packages/backend/src/hook/hook.controller.ts  |   5 +
 packages/backend/src/list/list.controller.ts  |  30 ++++-
 .../src/list/list.persistence.service.ts      |  30 ++++-
 .../backend/src/list/list.service.spec.ts     |  21 +--
 packages/backend/src/list/list.service.ts     |  42 +++---
 .../backend/src/memory/memory.controller.ts   |   7 +-
 packages/backend/src/mock/mock.controller.ts  |  11 +-
 packages/backend/src/mock/mock.service.ts     |   4 +-
 .../backend/src/muzzle/muzzle.controller.ts   |  15 ++-
 .../src/muzzle/muzzle.persistence.service.ts  |  23 +++-
 .../src/portfolio/portfolio.controller.ts     |  90 +++++++++----
 .../portfolio.persistence.service.ts          |  12 +-
 .../src/portfolio/portfolio.service.ts        |  24 +++-
 .../backend/src/quote/quote.controller.ts     |  11 +-
 packages/backend/src/quote/quote.service.ts   |  13 +-
 .../src/reaction/reaction.controller.ts       |   6 +-
 .../reaction/reaction.persistence.service.ts  |  34 ++++-
 .../src/reaction/reaction.service.spec.ts     |  16 ++-
 .../backend/src/reaction/reaction.service.ts  |  11 +-
 .../src/shared/logger/error-logging.ts        |  46 +++++++
 packages/backend/src/shared/logger/logger.ts  | 121 +++++++++++++++++-
 .../services/history.persistence.service.ts   |  40 +++++-
 .../slack/slack.persistence.service.ts        |  19 ++-
 .../services/slack/slack.service.spec.ts      |  27 +++-
 .../shared/services/slack/slack.service.ts    |  20 ++-
 .../src/shared/services/web/web.service.ts    |  67 +++++++---
 packages/backend/src/store/item.service.ts    |  30 ++++-
 .../backend/src/store/store.controller.ts     |  24 ++--
 .../src/store/store.persistence.service.ts    |   9 +-
 packages/backend/src/store/store.service.ts   |  22 +++-
 .../backend/src/walkie/walkie.controller.ts   |  12 +-
 packages/backend/src/walkie/walkie.service.ts |   4 +-
 54 files changed, 1047 insertions(+), 196 deletions(-)
 create mode 100644 packages/backend/src/shared/logger/error-logging.ts

diff --git a/README.md b/README.md
index 5d94a401..1fbda1d5 100644
--- a/README.md
+++ b/README.md
@@ -120,3 +120,30 @@ You can also run workspace-specific commands using:
 npm run <script> -w @mocker/backend
 npm run <script> -w @mocker/frontend
 ```
+
+## Docker Logs
+
+The backend writes structured JSON logs to stdout so deployed failures can be investigated directly with `docker logs`.
+
+Each log entry includes:
+
+- `timestamp`
+- `level`
+- `module`
+- `message`
+- `context`
+- `error.name`
+- `error.message`
+- `error.stack`
+
+Useful commands:
+
+```bash
+docker logs <container-name>
+docker logs <container-name> | grep '"level":"error"'
+docker logs <container-name> | grep '"module":"AIService"'
+docker logs <container-name> | grep '"channelId":"C123"'
+docker logs <container-name> | jq .
+```
+
+The `context` object is where request-specific identifiers live, such as `userId`, `teamId`, `channelId`, `itemId`, `symbol`, and prompt text. In production, start with `module` and `message`, then use `context` to isolate the failing request, and finally inspect `error.stack` for the root cause.
diff --git a/packages/backend/Dockerfile b/packages/backend/Dockerfile
index a655b493..d87f8b23 100644
--- a/packages/backend/Dockerfile
+++ b/packages/backend/Dockerfile
@@ -13,19 +13,18 @@ COPY packages/backend/src ./packages/backend/src
 # Build backend artifact inside Docker.
 RUN npm ci \
 	&& npm run build:prod -w @mocker/backend \
-	&& npm prune --omit=dev \
-	&& mkdir -p /usr/src/app/images
+	&& npm prune --omit=dev
 
 FROM gcr.io/distroless/nodejs20-debian12:nonroot AS release
 ENV NODE_ENV=production \
-	PORT=80
+	PORT=80 \
+	IMAGE_DIR=/tmp/mocker-images
 
 WORKDIR /usr/src/app
 
-# Copy backend build artifacts and writable path from build stage.
+# Copy backend build artifacts. Runtime-generated images are written under /tmp.
 COPY --from=build --chown=65532:65532 /usr/src/app/packages/backend/dist ./dist
 COPY --from=build --chown=65532:65532 /usr/src/app/node_modules ./node_modules
-COPY --from=build --chown=65532:65532 --chmod=700 /usr/src/app/images ./images
 
 EXPOSE 80
 
diff --git a/packages/backend/src/ai/ai.controller.ts b/packages/backend/src/ai/ai.controller.ts
index 74754bba..022f3a98 100644
--- a/packages/backend/src/ai/ai.controller.ts
+++ b/packages/backend/src/ai/ai.controller.ts
@@ -6,6 +6,7 @@ import { suppressedMiddleware } from '../shared/middleware/suppression';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
 import { aiMiddleware } from './middleware/aiMiddleware';
 import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export const aiController: Router = express.Router();
@@ -21,7 +22,12 @@ aiController.post('/text', (req, res) => {
   const { user_id, team_id, channel_id, text } = req.body;
   res.status(200).send('Processing your request. Please be patient...');
   void aiService.generateText(user_id, team_id, channel_id, text).catch((e) => {
-    aiLogger.error(e);
+    logError(aiLogger, 'Failed to generate AI text response', e, {
+      userId: user_id,
+      teamId: team_id,
+      channelId: channel_id,
+      prompt: text,
+    });
     const errorMessage = `\`Sorry! Your request for ${text} failed. Please try again.\``;
     void webService.sendEphemeral(channel_id, errorMessage, user_id);
     return undefined;
@@ -32,7 +38,12 @@ aiController.post('/image', (req, res) => {
   const { user_id, team_id, channel_id, text } = req.body;
   res.status(200).send('Processing your request. Please be patient...');
   void aiService.generateImage(user_id, team_id, channel_id, text).catch((e) => {
-    aiLogger.error(e);
+    logError(aiLogger, 'Failed to generate AI image response', e, {
+      userId: user_id,
+      teamId: team_id,
+      channelId: channel_id,
+      prompt: text,
+    });
     const errorMessage = `\`Sorry! Your request for ${text} failed. Please try again.\``;
     void webService.sendEphemeral(channel_id, errorMessage, user_id);
     return undefined;
@@ -43,7 +54,12 @@ aiController.post('/prompt-with-history', (req, res) => {
   const request: SlashCommandRequest = req.body;
   res.status(200).send('Processing your request. Please be patient...');
   void aiService.promptWithHistory(request).catch((e) => {
-    aiLogger.error(e);
+    logError(aiLogger, 'Failed to process AI prompt with history', e, {
+      userId: request.user_id,
+      teamId: request.team_id,
+      channelId: request.channel_id,
+      prompt: request.text,
+    });
     const errorMessage = `\`Sorry! Your request for ${request.text} failed. Please try again.\``;
     void webService.sendEphemeral(request.channel_id, errorMessage, request.user_id);
     return undefined;
diff --git a/packages/backend/src/ai/ai.service.spec.ts b/packages/backend/src/ai/ai.service.spec.ts
index b810e3e1..945d8914 100644
--- a/packages/backend/src/ai/ai.service.spec.ts
+++ b/packages/backend/src/ai/ai.service.spec.ts
@@ -1,3 +1,6 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 import { AIService } from './ai.service';
 import type { MessageWithName } from '../shared/models/message/message-with-name';
 import { MOONBEAM_SLACK_ID } from './ai.constants';
@@ -155,6 +158,33 @@ describe('AIService', () => {
     });
   });
 
+  describe('writeToDiskAndReturnUrl', () => {
+    it('creates the image directory before writing the file', async () => {
+      const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-service-'));
+      const imageDir = path.join(tempRoot, 'nested', 'images');
+      const originalImageDir = process.env.IMAGE_DIR;
+
+      process.env.IMAGE_DIR = imageDir;
+
+      try {
+        const imageUrl = await aiService.writeToDiskAndReturnUrl(Buffer.from('png-bytes').toString('base64'));
+        const filename = imageUrl.split('/').pop();
+
+        expect(filename).toBeDefined();
+        expect(fs.existsSync(imageDir)).toBe(true);
+        expect(fs.readFileSync(path.join(imageDir, filename as string))).toEqual(Buffer.from('png-bytes'));
+      } finally {
+        if (originalImageDir === undefined) {
+          delete process.env.IMAGE_DIR;
+        } else {
+          process.env.IMAGE_DIR = originalImageDir;
+        }
+
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+      }
+    });
+  });
+
   describe('redeployMoonbeam', () => {
     it('publishes deployment message with quote and image', async () => {
       (aiService.openAi.responses.create as jest.Mock).mockResolvedValue({
diff --git a/packages/backend/src/ai/ai.service.ts b/packages/backend/src/ai/ai.service.ts
index ba7ebaaf..e9097f4a 100644
--- a/packages/backend/src/ai/ai.service.ts
+++ b/packages/backend/src/ai/ai.service.ts
@@ -24,6 +24,7 @@ import {
 } from './ai.constants';
 import { MemoryPersistenceService } from './memory/memory.persistence.service';
 import type { MemoryWithSlackId } from '../shared/db/models/Memory';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 import { SlackService } from '../shared/services/slack/slack.service';
 import { MuzzlePersistenceService } from '../muzzle/muzzle.persistence.service';
@@ -55,6 +56,8 @@ const extractAndParseOpenAiResponse = (response: OpenAI.Responses.Response): str
   return outputText?.trim();
 };
 
+const DEFAULT_IMAGE_DIR = path.join('/tmp', 'mocker-images');
+
 export class AIService {
   redis = new AIPersistenceService();
   openAi = new OpenAI({
@@ -110,7 +113,12 @@ export class AIService {
         }
       })
       .catch(async (e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to generate AI text response', e, {
+          userId,
+          teamId,
+          channelId,
+          prompt: text,
+        });
         await this.redis.removeInflight(userId, teamId);
         await this.redis.decrementDailyRequests(userId, teamId);
         throw e;
@@ -118,19 +126,22 @@ export class AIService {
   }
 
   public async writeToDiskAndReturnUrl(base64Image: string): Promise<string> {
-    const dir = process.env.IMAGE_DIR ? process.env.IMAGE_DIR : path.join(__dirname, '../../../images');
+    const dir = process.env.IMAGE_DIR ?? DEFAULT_IMAGE_DIR;
     const filename = `${uuidv4()}.png`;
     const filePath = path.join(dir, filename);
     const base64Data = base64Image.replace(/^data:image\/png;base64,/, '');
-    return new Promise((resolve, reject) =>
-      fs.writeFile(filePath, base64Data, 'base64', (err) => {
-        if (err) {
-          this.aiServiceLogger.error('Error writing image to disk:', err);
-          reject(err);
-        }
-        resolve(`https://muzzle.lol/${filename}`);
-      }),
-    );
+
+    try {
+      await fs.promises.mkdir(dir, { recursive: true });
+      await fs.promises.writeFile(filePath, base64Data, 'base64');
+      return `https://muzzle.lol/${filename}`;
+    } catch (error) {
+      logError(this.aiServiceLogger, 'Failed to write AI image to disk', error, {
+        imageDirectory: dir,
+        filePath,
+      });
+      throw error;
+    }
   }
 
   public async redeployMoonbeam(): Promise<void> {
@@ -191,8 +202,11 @@ export class AIService {
         if (x) {
           return this.writeToDiskAndReturnUrl(x);
         } else {
-          this.aiServiceLogger.error(`No b64_json was returned for prompt: ${REDPLOY_MOONBEAM_IMAGE_PROMPT}`);
-          throw new Error(`No b64_json was returned for prompt: ${REDPLOY_MOONBEAM_IMAGE_PROMPT}`);
+          const error = new Error(`No b64_json was returned for prompt: ${REDPLOY_MOONBEAM_IMAGE_PROMPT}`);
+          logError(this.aiServiceLogger, 'Gemini redeploy image generation returned no image data', error, {
+            prompt: REDPLOY_MOONBEAM_IMAGE_PROMPT,
+          });
+          throw error;
         }
       });
 
@@ -217,7 +231,7 @@ export class AIService {
         void this.webService.sendMessage('#muzzlefeedback', 'Moonbeam has been deployed.', blocks);
       })
       .catch((e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to redeploy Moonbeam assets', e);
       });
   }
 
@@ -274,15 +288,26 @@ export class AIService {
         if (x) {
           return this.writeToDiskAndReturnUrl(x);
         } else {
-          this.aiServiceLogger.error(`No b64_json was returned for prompt: ${text}`);
-          throw new Error(`No b64_json was returned for prompt: ${text}`);
+          const error = new Error(`No b64_json was returned for prompt: ${text}`);
+          logError(this.aiServiceLogger, 'Gemini image generation returned no image data', error, {
+            userId,
+            teamId,
+            channelId: channel,
+            prompt: text,
+          });
+          throw error;
         }
       })
       .then((imageUrl) => {
         this.sendImage(imageUrl, userId, teamId, channel, text);
       })
       .catch(async (e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to generate AI image response', e, {
+          userId,
+          teamId,
+          channelId: channel,
+          prompt: text,
+        });
         await this.redis.removeInflight(userId, teamId);
         await this.redis.decrementDailyRequests(userId, teamId);
         throw e;
@@ -296,7 +321,9 @@ export class AIService {
         return extractAndParseOpenAiResponse(x);
       })
       .catch(async (e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to generate corpo-speak response', e, {
+          prompt: text,
+        });
         throw e;
       });
   }
@@ -370,7 +397,12 @@ export class AIService {
         });
 
         this.webService.sendMessage(request.channel_id, request.text, blocks).catch((e) => {
-          this.aiServiceLogger.error(e);
+          logError(this.aiServiceLogger, 'Failed to send prompt-with-history response to Slack', e, {
+            userId: request.user_id,
+            teamId: request.team_id,
+            channelId: request.channel_id,
+            prompt: request.text,
+          });
           void this.webService.sendMessage(
             request.user_id,
             'Sorry, unable to send the requested text to Slack. You have been credited for your Moon Token. Perhaps you were trying to send in a private channel? If so, invite @MoonBeam and try again.',
@@ -378,7 +410,12 @@ export class AIService {
         });
       })
       .catch(async (e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to process prompt with history', e, {
+          userId: request.user_id,
+          teamId: request.team_id,
+          channelId: request.channel_id,
+          prompt: request.text,
+        });
         await this.redis.removeInflight(user_id, team_id);
         await this.redis.decrementDailyRequests(user_id, team_id);
         throw e;
@@ -420,7 +457,12 @@ export class AIService {
           this.webService
             .sendMessage(channelId, result, [{ type: 'markdown', text: result }])
             .then(() => this.redis.setHasParticipated(teamId, channelId))
-            .catch((e) => this.aiServiceLogger.error('Error sending AI Participation message:', e));
+            .catch((e) =>
+              logError(this.aiServiceLogger, 'Failed to send AI participation message', e, {
+                teamId,
+                channelId,
+              }),
+            );
 
           // Fire-and-forget: extract memories from this conversation
           this.extractMemories(teamId, channelId, history, result, participantSlackIds).catch((e) =>
@@ -429,7 +471,11 @@ export class AIService {
         }
       })
       .catch(async (e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to generate AI participation response', e, {
+          teamId,
+          channelId,
+          taggedMessage,
+        });
         throw e;
       })
       .finally(() => {
@@ -655,7 +701,12 @@ export class AIService {
         },
       ];
       this.webService.sendMessage(channel, text, blocks).catch((e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to send generated AI image to Slack', e, {
+          userId,
+          teamId,
+          channelId: channel,
+          prompt: text,
+        });
         void this.decrementDaiyRequests(userId, teamId);
         void this.webService.sendMessage(
           userId,
@@ -686,7 +737,12 @@ export class AIService {
       });
 
       this.webService.sendMessage(channelId, text, blocks).catch((e) => {
-        this.aiServiceLogger.error(e);
+        logError(this.aiServiceLogger, 'Failed to send generated AI text to Slack', e, {
+          userId,
+          teamId,
+          channelId,
+          prompt: query,
+        });
         void this.decrementDaiyRequests(userId, teamId);
         void this.webService.sendMessage(
           userId,
diff --git a/packages/backend/src/ai/memory/memory.persistence.service.ts b/packages/backend/src/ai/memory/memory.persistence.service.ts
index e1770a04..d5e36bdc 100644
--- a/packages/backend/src/ai/memory/memory.persistence.service.ts
+++ b/packages/backend/src/ai/memory/memory.persistence.service.ts
@@ -2,6 +2,7 @@ import { getRepository } from 'typeorm';
 import type { MemoryWithSlackId } from '../../shared/db/models/Memory';
 import { Memory } from '../../shared/db/models/Memory';
 import { SlackUser } from '../../shared/db/models/SlackUser';
+import { logError } from '../../shared/logger/error-logging';
 import { logger } from '../../shared/logger/logger';
 
 export class MemoryPersistenceService {
@@ -25,7 +26,11 @@ export class MemoryPersistenceService {
     return getRepository(Memory)
       .save(memories)
       .catch((e) => {
-        this.logger.error('Error saving memories:', e);
+        logError(this.logger, 'Error saving memories', e, {
+          slackId,
+          teamId,
+          memoryCount: contents.length,
+        });
         return [];
       });
   }
@@ -40,7 +45,10 @@ export class MemoryPersistenceService {
         [slackId, teamId],
       )
       .catch((e) => {
-        this.logger.error('Error fetching all memories for user:', e);
+        logError(this.logger, 'Error fetching all memories for user', e, {
+          slackId,
+          teamId,
+        });
         return [];
       });
   }
@@ -64,7 +72,7 @@ export class MemoryPersistenceService {
       .query('UPDATE memory SET updatedAt = CURRENT_TIMESTAMP WHERE id = ?', [memoryId])
       .then(() => true)
       .catch((e) => {
-        this.logger.error('Error reinforcing memory:', e);
+        logError(this.logger, 'Error reinforcing memory', e, { memoryId });
         return false;
       });
   }
@@ -74,7 +82,7 @@ export class MemoryPersistenceService {
       .delete({ id: memoryId })
       .then((result) => (result.affected ?? 0) > 0)
       .catch((e) => {
-        this.logger.error('Error deleting memory:', e);
+        logError(this.logger, 'Error deleting memory', e, { memoryId });
         return false;
       });
   }
diff --git a/packages/backend/src/backfire/backfire.persistence.service.ts b/packages/backend/src/backfire/backfire.persistence.service.ts
index c982fa81..de0ef58f 100644
--- a/packages/backend/src/backfire/backfire.persistence.service.ts
+++ b/packages/backend/src/backfire/backfire.persistence.service.ts
@@ -2,9 +2,12 @@ import type { UpdateResult } from 'typeorm';
 import { getRepository } from 'typeorm';
 import { RedisPersistenceService } from '../shared/services/redis.persistence.service';
 import { Backfire } from '../shared/db/models/Backfire';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export class BackFirePersistenceService {
   private redis: RedisPersistenceService = RedisPersistenceService.getInstance();
+  private logger = logger.child({ module: 'BackfirePersistenceService' });
 
   public addBackfire(userId: string, time: number, teamId: string): Promise<void> {
     const backfire = new Backfire();
@@ -30,6 +33,14 @@ export class BackFirePersistenceService {
           'EX',
           Math.floor(time / 1000),
         );
+      })
+      .catch((e) => {
+        logError(this.logger, 'Failed to create backfire state', e, {
+          userId,
+          teamId,
+          time,
+        });
+        throw e;
       });
   }
 
diff --git a/packages/backend/src/backfire/backfire.service.ts b/packages/backend/src/backfire/backfire.service.ts
index a3d77c73..9efe6ba5 100644
--- a/packages/backend/src/backfire/backfire.service.ts
+++ b/packages/backend/src/backfire/backfire.service.ts
@@ -1,5 +1,6 @@
 import { ABUSE_PENALTY_TIME, MAX_SUPPRESSIONS } from '../muzzle/constants';
 import { getTimeString } from '../muzzle/muzzle-utilities';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 import type { EventRequest } from '../shared/models/slack/slack-models';
 import { SuppressorService } from '../shared/services/suppressor.service';
@@ -75,7 +76,13 @@ export class BackfireService extends SuppressorService {
                 ABUSE_PENALTY_TIME,
               )} :rotating_light:`,
             )
-            .catch((e) => this.logger.error(e));
+            .catch((e) =>
+              logError(this.logger, 'Failed to send backfire abuse warning', e, {
+                channelId: request.event.channel,
+                userId: request.event.user,
+                teamId: request.team_id,
+              }),
+            );
         }
       }
     }
diff --git a/packages/backend/src/clap/clap.controller.ts b/packages/backend/src/clap/clap.controller.ts
index b73d085e..bca95859 100644
--- a/packages/backend/src/clap/clap.controller.ts
+++ b/packages/backend/src/clap/clap.controller.ts
@@ -3,15 +3,24 @@ import express from 'express';
 import { ClapService } from './clap.service';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export const clapController: Router = express.Router();
 clapController.use(textMiddleware);
 clapController.use(suppressedMiddleware);
 
 const clapService = new ClapService();
+const clapLogger = logger.child({ module: 'ClapController' });
 
 clapController.post('/', (req, res) => {
   const { text, user_id, response_url } = req.body;
-  clapService.clap(text, user_id, response_url);
+  void Promise.resolve(clapService.clap(text, user_id, response_url)).catch((e) => {
+    logError(clapLogger, 'Failed to handle /clap request', e, {
+      userId: user_id,
+      responseUrl: response_url,
+      text,
+    });
+  });
   res.status(200).send();
 });
diff --git a/packages/backend/src/clap/clap.service.ts b/packages/backend/src/clap/clap.service.ts
index e6be67f6..e1160c22 100644
--- a/packages/backend/src/clap/clap.service.ts
+++ b/packages/backend/src/clap/clap.service.ts
@@ -1,10 +1,12 @@
 import type { ChannelResponse } from '../shared/models/slack/slack-models';
+import { logger } from '../shared/logger/logger';
 import { SlackService } from '../shared/services/slack/slack.service';
 
 export class ClapService {
   slackService = new SlackService();
+  logger = logger.child({ module: 'ClapService' });
 
-  public clap(text: string, userId: string, responseUrl: string): void {
+  public async clap(text: string, userId: string, responseUrl: string): Promise<void> {
     if (text) {
       let output = '';
       const words = text.trim().split(' ');
diff --git a/packages/backend/src/confession/confession.controller.ts b/packages/backend/src/confession/confession.controller.ts
index e790f9db..14af4b39 100644
--- a/packages/backend/src/confession/confession.controller.ts
+++ b/packages/backend/src/confession/confession.controller.ts
@@ -3,15 +3,24 @@ import express from 'express';
 import { ConfessionService } from './confession.service';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export const confessionController: Router = express.Router();
 confessionController.use(suppressedMiddleware);
 confessionController.use(textMiddleware);
 
 const confessionService = new ConfessionService();
+const confessionLogger = logger.child({ module: 'ConfessionController' });
 
 confessionController.post('/', (req, res) => {
   res.status(200).send();
   const { user_id, channel_id, text } = req.body;
-  void confessionService.confess(user_id, channel_id, text);
+  void confessionService.confess(user_id, channel_id, text).catch((e) => {
+    logError(confessionLogger, 'Failed to handle /confession request', e, {
+      userId: user_id,
+      channelId: channel_id,
+      text,
+    });
+  });
 });
diff --git a/packages/backend/src/confession/confession.service.spec.ts b/packages/backend/src/confession/confession.service.spec.ts
index 18bd9a5a..22c873a4 100644
--- a/packages/backend/src/confession/confession.service.spec.ts
+++ b/packages/backend/src/confession/confession.service.spec.ts
@@ -30,6 +30,12 @@ describe('ConfessionService', () => {
     await service.confess('U1', 'C1', 'bad');
     await Promise.resolve();
 
-    expect(loggerSpy).toHaveBeenCalledWith(err);
+    expect(loggerSpy).toHaveBeenCalledWith(
+      'Failed to send confession message',
+      expect.objectContaining({
+        context: { channelId: 'C1', requestorId: 'U1' },
+        error: expect.objectContaining({ message: 'boom', name: 'Error' }),
+      }),
+    );
   });
 });
diff --git a/packages/backend/src/confession/confession.service.ts b/packages/backend/src/confession/confession.service.ts
index 27398463..2895ca46 100644
--- a/packages/backend/src/confession/confession.service.ts
+++ b/packages/backend/src/confession/confession.service.ts
@@ -1,3 +1,4 @@
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 import { SlackService } from '../shared/services/slack/slack.service';
 import { WebService } from '../shared/services/web/web.service';
@@ -8,8 +9,11 @@ export class ConfessionService {
   logger = logger.child({ module: 'ConfessionService' });
 
   public async confess(requestorId: string, channelId: string, confession: string): Promise<void> {
-    this.webService
-      .sendMessage(channelId, `:chicken: <@${requestorId}> :chicken: says: \`${confession}\``)
-      .catch((e) => this.logger.error(e));
+    this.webService.sendMessage(channelId, `:chicken: <@${requestorId}> :chicken: says: \`${confession}\``).catch((e) =>
+      logError(this.logger, 'Failed to send confession message', e, {
+        requestorId,
+        channelId,
+      }),
+    );
   }
 }
diff --git a/packages/backend/src/counter/counter.controller.ts b/packages/backend/src/counter/counter.controller.ts
index f0a1149a..1e010cb7 100644
--- a/packages/backend/src/counter/counter.controller.ts
+++ b/packages/backend/src/counter/counter.controller.ts
@@ -4,6 +4,7 @@ import { CounterPersistenceService } from './counter.persistence.service';
 import { CounterService } from './counter.service';
 import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export const counterController: Router = express.Router();
@@ -22,7 +23,10 @@ counterController.post('/', (req, res) => {
       .createCounter(request.user_id, request.team_id)
       .then((value) => res.send(value))
       .catch((e) => {
-        counterLogger.error(e);
+        logError(counterLogger, 'Failed to create counter', e, {
+          requestorId: request.user_id,
+          teamId: request.team_id,
+        });
         res.send(e);
       });
   }
diff --git a/packages/backend/src/counter/counter.persistence.service.ts b/packages/backend/src/counter/counter.persistence.service.ts
index 38f12c95..af458f33 100644
--- a/packages/backend/src/counter/counter.persistence.service.ts
+++ b/packages/backend/src/counter/counter.persistence.service.ts
@@ -6,6 +6,7 @@ import { WebService } from '../shared/services/web/web.service';
 import { COUNTER_TIME, SINGLE_DAY_MS } from './constants';
 import { MuzzlePersistenceService } from '../muzzle/muzzle.persistence.service';
 import { getRemainingTime } from '../muzzle/muzzle-utilities';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 export class CounterPersistenceService {
   public static getInstance(): CounterPersistenceService {
@@ -34,7 +35,10 @@ export class CounterPersistenceService {
       this.setCounterState(requestorId, counterFromDb.id, teamId);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
-      this.logger.error(`Error on saving counter to DB: ${error}`);
+      logError(this.logger, 'Error saving counter to DB', error, {
+        requestorId,
+        teamId,
+      });
       throw Object.assign(new Error(`Error on saving counter to DB: ${error.message}`), { cause: error });
     }
   }
@@ -134,9 +138,12 @@ export class CounterPersistenceService {
     clearTimeout(counter!.removalFn);
     if (isUsed && channel) {
       this.counters.delete(id);
-      await this.setCounteredToTrue(id, requestorId).catch((e) =>
-        this.logger.error('Error during setCounteredToTrue', e),
-      );
+      await this.setCounteredToTrue(id, requestorId).catch((e) => {
+        logError(this.logger, 'Failed to mark counter as used', e, {
+          counterId: id,
+          requestorId,
+        });
+      });
     } else {
       // This whole section is an anti-pattern. Fix this.
       this.counters.delete(id);
@@ -150,7 +157,13 @@ export class CounterPersistenceService {
             counter!.requestorId
           }> lives in fear and is now muzzled, has lost muzzle privileges for 24 hours and cannot use counter again for 24 hours. :flesh:`,
         )
-        .catch((e) => this.logger.error(e));
+        .catch((e) =>
+          logError(this.logger, 'Failed to send counter timeout message', e, {
+            counterId: id,
+            requestorId: counter!.requestorId,
+            teamId,
+          }),
+        );
     }
   }
 
diff --git a/packages/backend/src/counter/counter.service.ts b/packages/backend/src/counter/counter.service.ts
index 91dcf890..a885abc0 100644
--- a/packages/backend/src/counter/counter.service.ts
+++ b/packages/backend/src/counter/counter.service.ts
@@ -4,6 +4,7 @@ import { SuppressorService } from '../shared/services/suppressor.service';
 import { ABUSE_PENALTY_TIME, MAX_SUPPRESSIONS } from '../muzzle/constants';
 import { getTimeString } from '../muzzle/muzzle-utilities';
 import type { EventRequest } from '../shared/models/slack/slack-models';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export class CounterService extends SuppressorService {
@@ -69,7 +70,14 @@ export class CounterService extends SuppressorService {
           channel,
           `:crossed_swords: <@${userId}> successfully countered <@${requestorId}>! <@${requestorId}> has lost muzzle privileges for 24 hours and is muzzled for the next 5 minutes! :crossed_swords:`,
         )
-        .catch((e) => this.logger.error(e));
+        .catch((e) =>
+          logError(this.logger, 'Failed to send counter success message', e, {
+            channel,
+            userId,
+            requestorId,
+            teamId,
+          }),
+        );
     }
   }
 
@@ -99,7 +107,13 @@ export class CounterService extends SuppressorService {
               ABUSE_PENALTY_TIME,
             )} :rotating_light:`,
           )
-          .catch((e) => this.logger.error(e));
+          .catch((e) =>
+            logError(this.logger, 'Failed to send counter abuse warning', e, {
+              channelId: request.event.channel,
+              userId: request.event.user,
+              teamId: request.team_id,
+            }),
+          );
       }
     }
   }
diff --git a/packages/backend/src/define/define.controller.ts b/packages/backend/src/define/define.controller.ts
index 5ff8f728..4b4f495a 100644
--- a/packages/backend/src/define/define.controller.ts
+++ b/packages/backend/src/define/define.controller.ts
@@ -3,6 +3,7 @@ import express from 'express';
 import { DefineService } from './define.service';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export const defineController: Router = express.Router();
@@ -16,7 +17,11 @@ defineController.post('/', (req: Request, res: Response) => {
   const { user_id, channel_id, text } = req.body;
   res.status(200).send();
   defineService.define(text, user_id, channel_id).catch((e) => {
-    defineLogger.error(e);
+    logError(defineLogger, 'Failed to handle /define request', e, {
+      userId: user_id,
+      channelId: channel_id,
+      text,
+    });
     res.send('Something went wrong while retrieving your definition');
   });
 });
diff --git a/packages/backend/src/define/define.service.ts b/packages/backend/src/define/define.service.ts
index efa0bd8a..051eaa1f 100644
--- a/packages/backend/src/define/define.service.ts
+++ b/packages/backend/src/define/define.service.ts
@@ -2,6 +2,7 @@ import type { KnownBlock } from '@slack/web-api';
 import type { AxiosResponse } from 'axios';
 import Axios from 'axios';
 import type { Definition, UrbanDictionaryResponse } from '../shared/models/define/define-models';
+import { logError } from '../shared/logger/error-logging';
 import { WebService } from '../shared/services/web/web.service';
 import { logger } from '../shared/logger/logger';
 
@@ -52,7 +53,21 @@ export class DefineService {
             },
           ],
         });
-        this.webService.sendMessage(channelId, formattedTitle, blocks).catch((e) => this.logger.error(e));
+        this.webService.sendMessage(channelId, formattedTitle, blocks).catch((e) =>
+          logError(this.logger, 'Failed to send definition response to Slack', e, {
+            userId,
+            channelId,
+            word,
+          }),
+        );
+      })
+      .catch((e) => {
+        logError(this.logger, 'Failed to fetch definition from Urban Dictionary', e, {
+          userId,
+          channelId,
+          word,
+        });
+        throw e;
       });
   }
 
diff --git a/packages/backend/src/event/event.controller.ts b/packages/backend/src/event/event.controller.ts
index 175cad47..de6d2dd2 100644
--- a/packages/backend/src/event/event.controller.ts
+++ b/packages/backend/src/event/event.controller.ts
@@ -2,6 +2,7 @@ import type { Request, Response, Router } from 'express';
 import express from 'express';
 import type { EventRequest } from '../shared/models/slack/slack-models';
 import { EventService } from './event.service';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export const eventController: Router = express.Router();
@@ -16,7 +17,12 @@ eventController.post('/handle', (req: Request, res: Response) => {
   } else {
     const request: EventRequest = req.body;
     eventService.handle(request).catch((error) => {
-      eventLogger.error('Error handling event:', error);
+      logError(eventLogger, 'Failed to handle Slack event', error, {
+        eventType: request.event.type,
+        teamId: request.team_id,
+        channelId: request.event.channel,
+        userId: request.event.user,
+      });
       return;
     });
     res.status(200).send();
diff --git a/packages/backend/src/event/event.persistence.service.ts b/packages/backend/src/event/event.persistence.service.ts
index b7fa0735..0c5004c6 100644
--- a/packages/backend/src/event/event.persistence.service.ts
+++ b/packages/backend/src/event/event.persistence.service.ts
@@ -6,9 +6,12 @@ import type { EventRequest } from '../shared/models/slack/slack-models';
 import type { AnalysisOptions, AnalysisResult } from 'sentiment';
 import Sentiment from 'sentiment';
 import { Sentiment as SentimentDB } from '../shared/db/models/Sentiment';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export class EventPersistenceService {
   sentiment = new Sentiment();
+  logger = logger.child({ module: 'EventPersistenceService' });
 
   async logActivity(request: EventRequest) {
     // This is a bandaid to stop workflows from breaking the service.
@@ -31,7 +34,16 @@ export class EventPersistenceService {
     activity.teamId = request.team_id;
     activity.userId = user;
     activity.eventType = request.event.type;
-    void getRepository(Activity).insert(activity);
+    void getRepository(Activity)
+      .insert(activity)
+      .catch((e) => {
+        logError(this.logger, 'Failed to persist Slack activity event', e, {
+          eventType: request.event.type,
+          teamId: request.team_id,
+          userId: request.event.user,
+          channelId: activity.channel,
+        });
+      });
   }
 
   public performSentimentAnalysis(userId: string, teamId: string, channelId: string, text: string): void {
@@ -56,6 +68,15 @@ export class EventPersistenceService {
     sentimentModel.teamId = teamId;
     sentimentModel.userId = userId;
     sentimentModel.channelId = channelId;
-    return getRepository(SentimentDB).insert(sentimentModel);
+    return getRepository(SentimentDB)
+      .insert(sentimentModel)
+      .catch((e) => {
+        logError(this.logger, 'Failed to persist sentiment analysis', e, {
+          userId,
+          teamId,
+          channelId,
+        });
+        throw e;
+      });
   }
 }
diff --git a/packages/backend/src/event/event.service.spec.ts b/packages/backend/src/event/event.service.spec.ts
index caeac365..fdb0dfd5 100644
--- a/packages/backend/src/event/event.service.spec.ts
+++ b/packages/backend/src/event/event.service.spec.ts
@@ -108,6 +108,17 @@ describe('EventService', () => {
       } as EventRequest),
     ).rejects.toThrow('handler failed');
 
-    expect(loggerSpy).toHaveBeenCalledWith('Error handling event:', err);
+    expect(loggerSpy).toHaveBeenCalledWith(
+      'Error handling event',
+      expect.objectContaining({
+        context: {
+          eventType: 'message',
+          teamId: 'T1',
+          channelId: 'C1',
+          userId: 'U1',
+        },
+        error: expect.objectContaining({ message: 'handler failed', name: 'Error' }),
+      }),
+    );
   });
 });
diff --git a/packages/backend/src/event/event.service.ts b/packages/backend/src/event/event.service.ts
index 765cafaa..571bce49 100644
--- a/packages/backend/src/event/event.service.ts
+++ b/packages/backend/src/event/event.service.ts
@@ -3,6 +3,7 @@ import { BackfireService } from '../backfire/backfire.service';
 import { CounterService } from '../counter/counter.service';
 import { MuzzleService } from '../muzzle/muzzle.service';
 import { ReactionService } from '../reaction/reaction.service';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 import type { EventRequest } from '../shared/models/slack/slack-models';
 import { HistoryPersistenceService } from '../shared/services/history.persistence.service';
@@ -59,7 +60,12 @@ export class EventService {
       this.aiService.handle(request),
     ];
     return Promise.all(handlers).catch((error) => {
-      this.logger.error('Error handling event:', error);
+      logError(this.logger, 'Error handling event', error, {
+        eventType: request.event.type,
+        teamId: request.team_id,
+        channelId: request.event.channel,
+        userId: request.event.user,
+      });
       throw error;
     });
   }
diff --git a/packages/backend/src/hook/hook.controller.ts b/packages/backend/src/hook/hook.controller.ts
index 5058ab79..d6c4aaed 100644
--- a/packages/backend/src/hook/hook.controller.ts
+++ b/packages/backend/src/hook/hook.controller.ts
@@ -1,5 +1,6 @@
 import type { Router } from 'express';
 import express from 'express';
+import { logError } from '../shared/logger/error-logging';
 import { WebService } from '../shared/services/web/web.service';
 
 export const hookController: Router = express.Router();
@@ -20,6 +21,10 @@ hookController.post('/', (req, res) => {
       res.status(200).send();
     })
     .catch((e) => {
+      logError(hookLogger, 'Failed to send hook message', e, {
+        message,
+        destination: '#products',
+      });
       res.status(500).send(`Error sending message: ${e.message}`);
     });
 });
diff --git a/packages/backend/src/list/list.controller.ts b/packages/backend/src/list/list.controller.ts
index e456fcc5..4ee7a13a 100644
--- a/packages/backend/src/list/list.controller.ts
+++ b/packages/backend/src/list/list.controller.ts
@@ -4,26 +4,50 @@ import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
 import { ListService } from './list.service';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export const listController: Router = express.Router();
 listController.use(suppressedMiddleware);
 
 const listService = new ListService();
+const listLogger = logger.child({ module: 'ListController' });
 
 listController.post('/retrieve', (req, res) => {
   const request: SlashCommandRequest = req.body;
-  void listService.getListReport(request);
+  void Promise.resolve(listService.getListReport(request)).catch((e) => {
+    logError(listLogger, 'Failed to retrieve list report', e, {
+      userId: request.user_id,
+      teamId: request.team_id,
+      channelId: request.channel_id,
+      channelName: request.channel_name,
+    });
+  });
   res.status(200).send();
 });
 
 listController.post('/add', textMiddleware, (req, res) => {
   const request: SlashCommandRequest = req.body;
-  void listService.list(request);
+  void Promise.resolve(listService.list(request)).catch((e) => {
+    logError(listLogger, 'Failed to add list item', e, {
+      userId: request.user_id,
+      teamId: request.team_id,
+      channelId: request.channel_id,
+      text: request.text,
+    });
+  });
   res.status(200).send();
 });
 
 listController.post('/remove', textMiddleware, (req, res) => {
   const request: SlashCommandRequest = req.body;
-  void listService.remove(request);
+  void Promise.resolve(listService.remove(request)).catch((e) => {
+    logError(listLogger, 'Failed to remove list item', e, {
+      userId: request.user_id,
+      teamId: request.team_id,
+      channelId: request.channel_id,
+      text: request.text,
+    });
+  });
   res.status(200).send();
 });
diff --git a/packages/backend/src/list/list.persistence.service.ts b/packages/backend/src/list/list.persistence.service.ts
index 248afc1e..0d10561b 100644
--- a/packages/backend/src/list/list.persistence.service.ts
+++ b/packages/backend/src/list/list.persistence.service.ts
@@ -1,20 +1,44 @@
 import { getRepository } from 'typeorm';
 import { List } from '../shared/db/models/List';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export class ListPersistenceService {
+  private logger = logger.child({ module: 'ListPersistenceService' });
+
   public store(requestorId: string, text: string, teamId: string, channelId: string): Promise<List> {
     const listItem = new List();
     listItem.requestorId = requestorId;
     listItem.text = text;
     listItem.teamId = teamId;
     listItem.channelId = channelId;
-    return getRepository(List).save(listItem);
+    return getRepository(List)
+      .save(listItem)
+      .catch((e) => {
+        logError(this.logger, 'Failed to store list item', e, {
+          requestorId,
+          teamId,
+          channelId,
+          text,
+        });
+        throw e;
+      });
   }
 
   public async remove(text: string): Promise<List> {
-    const item = await getRepository(List).findOne({ where: { text } });
+    const item = await getRepository(List)
+      .findOne({ where: { text } })
+      .catch((e) => {
+        logError(this.logger, 'Failed to retrieve list item for removal', e, { text });
+        throw e;
+      });
     if (item) {
-      return getRepository(List).remove(item);
+      return getRepository(List)
+        .remove(item)
+        .catch((e) => {
+          logError(this.logger, 'Failed to remove list item', e, { text, itemId: item.id });
+          throw e;
+        });
     }
 
     throw new Error(`Unable to find \`${text}\``);
diff --git a/packages/backend/src/list/list.service.spec.ts b/packages/backend/src/list/list.service.spec.ts
index 25797e41..cfd087ec 100644
--- a/packages/backend/src/list/list.service.spec.ts
+++ b/packages/backend/src/list/list.service.spec.ts
@@ -49,7 +49,7 @@ describe('ListService', () => {
     expect(uploadFile).toHaveBeenCalledWith('C1', expect.stringContaining('#general List'), "#general's List", 'U1');
   });
 
-  it('stores list item and sends in-channel response', () => {
+  it('stores list item and sends in-channel response', async () => {
     const req = {
       user_id: 'U1',
       text: 'buy milk',
@@ -58,7 +58,9 @@ describe('ListService', () => {
       response_url: 'https://resp',
     } as ListRequest;
 
-    service.list(req);
+    store.mockResolvedValue(undefined);
+
+    await service.list(req);
 
     expect(store).toHaveBeenCalledWith('U1', 'buy milk', 'T1', 'C1');
     expect(sendResponse).toHaveBeenCalledWith(
@@ -71,8 +73,7 @@ describe('ListService', () => {
     remove.mockResolvedValue(undefined);
     const req = { text: 'buy milk', response_url: 'https://resp' } as RemoveRequest;
 
-    service.remove(req);
-    await Promise.resolve();
+    await service.remove(req);
 
     expect(remove).toHaveBeenCalledWith('buy milk');
     expect(sendResponse).toHaveBeenCalledWith('https://resp', expect.objectContaining({ response_type: 'in_channel' }));
@@ -83,11 +84,15 @@ describe('ListService', () => {
     const loggerSpy = jest.spyOn(service.logger, 'error').mockImplementation(() => undefined);
     remove.mockRejectedValue(err);
 
-    service.remove({ text: 'x', response_url: 'https://resp' } as RemoveRequest);
-    await Promise.resolve();
-    await Promise.resolve();
+    await service.remove({ text: 'x', response_url: 'https://resp' } as RemoveRequest);
 
-    expect(loggerSpy).toHaveBeenCalledWith(err);
+    expect(loggerSpy).toHaveBeenCalledWith(
+      'Failed to remove list item',
+      expect.objectContaining({
+        context: expect.objectContaining({ text: 'x' }),
+        error: expect.objectContaining({ message: 'remove failed', name: 'Error' }),
+      }),
+    );
     expect(sendResponse).toHaveBeenCalledWith('https://resp', expect.objectContaining({ response_type: 'ephemeral' }));
   });
 });
diff --git a/packages/backend/src/list/list.service.ts b/packages/backend/src/list/list.service.ts
index 67c634f0..7ce3d840 100644
--- a/packages/backend/src/list/list.service.ts
+++ b/packages/backend/src/list/list.service.ts
@@ -5,6 +5,7 @@ import type { ListUser } from './ListUser.model';
 import { WebService } from '../shared/services/web/web.service';
 import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { ListPersistenceService } from './list.persistence.service';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export class ListService extends ReportService {
@@ -31,8 +32,8 @@ ${Table.print(reportWithoutDate)}
 `;
   }
 
-  list(request: SlashCommandRequest): void {
-    void this.listPersistenceService.store(request.user_id, request.text, request.team_id, request.channel_id);
+  async list(request: SlashCommandRequest): Promise<void> {
+    await this.listPersistenceService.store(request.user_id, request.text, request.team_id, request.channel_id);
     const response = {
       response_type: 'in_channel',
       text: `\`${request.text}\` has been \`listed\``,
@@ -40,23 +41,26 @@ ${Table.print(reportWithoutDate)}
     this.slackService.sendResponse(request.response_url, response);
   }
 
-  remove(request: SlashCommandRequest): void {
-    this.listPersistenceService
-      .remove(request.text)
-      .then(() => {
-        const response = {
-          response_type: 'in_channel',
-          text: `\`${request.text}\` has been removed from \`The List\``,
-        };
-        this.slackService.sendResponse(request.response_url, response);
-      })
-      .catch((e) => {
-        this.logger.error(e);
-        const errorResponse = {
-          response_type: 'ephemeral',
-          text: 'An error occurred while trying to remove the item from the list.',
-        };
-        this.slackService.sendResponse(request.response_url, errorResponse);
+  async remove(request: SlashCommandRequest): Promise<void> {
+    try {
+      await this.listPersistenceService.remove(request.text);
+      const response = {
+        response_type: 'in_channel',
+        text: `\`${request.text}\` has been removed from \`The List\``,
+      };
+      this.slackService.sendResponse(request.response_url, response);
+    } catch (e) {
+      logError(this.logger, 'Failed to remove list item', e, {
+        userId: request.user_id,
+        teamId: request.team_id,
+        channelId: request.channel_id,
+        text: request.text,
       });
+      const errorResponse = {
+        response_type: 'ephemeral',
+        text: 'An error occurred while trying to remove the item from the list.',
+      };
+      this.slackService.sendResponse(request.response_url, errorResponse);
+    }
   }
 }
diff --git a/packages/backend/src/memory/memory.controller.ts b/packages/backend/src/memory/memory.controller.ts
index 1483b341..650e39c1 100644
--- a/packages/backend/src/memory/memory.controller.ts
+++ b/packages/backend/src/memory/memory.controller.ts
@@ -3,6 +3,7 @@ import express from 'express';
 import { MemoryPersistenceService } from '../ai/memory/memory.persistence.service';
 import { WebService } from '../shared/services/web/web.service';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export const memoryController: Router = express.Router();
@@ -40,7 +41,11 @@ memoryController.post('/', (req, res) => {
       const message = `What Moonbeam remembers about you:\n${formattedMemories}`;
       void webService.sendEphemeral(channel_id, message, user_id);
     } catch (e) {
-      memoryLogger.error('Error fetching memories for /memory command:', e);
+      logError(memoryLogger, 'Failed to fetch memories for /memory command', e, {
+        userId: user_id,
+        teamId: team_id,
+        channelId: channel_id,
+      });
       void webService.sendEphemeral(channel_id, 'Sorry, something went wrong fetching your memories.', user_id);
     }
   })();
diff --git a/packages/backend/src/mock/mock.controller.ts b/packages/backend/src/mock/mock.controller.ts
index 42428df2..9616aa74 100644
--- a/packages/backend/src/mock/mock.controller.ts
+++ b/packages/backend/src/mock/mock.controller.ts
@@ -4,6 +4,8 @@ import { MockService } from './mock.service';
 import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export const mockController: Router = express.Router();
 
@@ -11,9 +13,16 @@ mockController.use(suppressedMiddleware);
 mockController.use(textMiddleware);
 
 const mockService = new MockService();
+const mockLogger = logger.child({ module: 'MockController' });
 
 mockController.post('/', (req, res) => {
   const request: SlashCommandRequest = req.body;
-  mockService.mock(request);
+  void Promise.resolve(mockService.mock(request)).catch((e) => {
+    logError(mockLogger, 'Failed to handle /mock request', e, {
+      userId: request.user_id,
+      responseUrl: request.response_url,
+      text: request.text,
+    });
+  });
   res.status(200).send();
 });
diff --git a/packages/backend/src/mock/mock.service.ts b/packages/backend/src/mock/mock.service.ts
index c6ec4b9c..e449da29 100644
--- a/packages/backend/src/mock/mock.service.ts
+++ b/packages/backend/src/mock/mock.service.ts
@@ -1,10 +1,12 @@
 import type { ChannelResponse, SlashCommandRequest } from '../shared/models/slack/slack-models';
+import { logger } from '../shared/logger/logger';
 import { SlackService } from '../shared/services/slack/slack.service';
 
 export class MockService {
   slackService = new SlackService();
+  logger = logger.child({ module: 'MockService' });
 
-  public mock(request: SlashCommandRequest): void {
+  public async mock(request: SlashCommandRequest): Promise<void> {
     if (request.text) {
       let mocked = '';
       let shouldChangeCase = true;
diff --git a/packages/backend/src/muzzle/muzzle.controller.ts b/packages/backend/src/muzzle/muzzle.controller.ts
index dd227b07..7c197881 100644
--- a/packages/backend/src/muzzle/muzzle.controller.ts
+++ b/packages/backend/src/muzzle/muzzle.controller.ts
@@ -9,6 +9,7 @@ import { MuzzleReportService } from './muzzle.report.service';
 import { MuzzleService } from './muzzle.service';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export const muzzleController: Router = express.Router();
@@ -31,7 +32,12 @@ muzzleController.post('/', (req: Request, res: Response) => {
       .addUserToMuzzled(userId, request.user_id, request.team_id, request.channel_name)
       .then((results) => res.send(results))
       .catch((e: unknown) => {
-        muzzleLogger.error(e);
+        logError(muzzleLogger, 'Failed to add user to muzzle list', e, {
+          muzzledUserId: userId,
+          requestorId: request.user_id,
+          teamId: request.team_id,
+          channelName: request.channel_name,
+        });
         res.status(500).send('An unexpected error occurred. Please try again later.');
       });
   } else {
@@ -66,7 +72,12 @@ muzzleController.post('/stats', (req: Request, res: Response) => {
         res.status(200).send();
       })
       .catch((e) => {
-        muzzleLogger.error(e);
+        logError(muzzleLogger, 'Failed to generate muzzle report', e, {
+          reportType,
+          userId: request.user_id,
+          teamId: request.team_id,
+          channelId: request.channel_id,
+        });
         res.status(500).send();
       });
   }
diff --git a/packages/backend/src/muzzle/muzzle.persistence.service.ts b/packages/backend/src/muzzle/muzzle.persistence.service.ts
index 535fcfcd..580b7a1f 100644
--- a/packages/backend/src/muzzle/muzzle.persistence.service.ts
+++ b/packages/backend/src/muzzle/muzzle.persistence.service.ts
@@ -3,12 +3,15 @@ import { getRepository } from 'typeorm';
 import { RedisPersistenceService } from '../shared/services/redis.persistence.service';
 import { SINGLE_DAY_MS } from '../counter/constants';
 import { Muzzle } from '../shared/db/models/Muzzle';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 import { StorePersistenceService } from '../store/store.persistence.service';
 import { MuzzleRedisTypeEnum, MAX_TIME_BETWEEN_MUZZLES, MAX_MUZZLES, ABUSE_PENALTY_TIME } from './constants';
 
 export class MuzzlePersistenceService {
   private redis: RedisPersistenceService = RedisPersistenceService.getInstance();
   private storePersistenceService = new StorePersistenceService();
+  private logger = logger.child({ module: 'MuzzlePersistenceService' });
 
   public addPermaMuzzle(userId: string, teamId: string): Promise<Muzzle> {
     const muzzle = new Muzzle();
@@ -28,6 +31,13 @@ export class MuzzlePersistenceService {
         );
         await this.redis.setValue(this.getRedisKeyName(userId, teamId, MuzzleRedisTypeEnum.Muzzled, true), '0');
         return muzzleFromDb;
+      })
+      .catch((e) => {
+        logError(this.logger, 'Failed to create permanent muzzle', e, {
+          userId,
+          teamId,
+        });
+        throw e;
       });
   }
 
@@ -60,7 +70,18 @@ export class MuzzlePersistenceService {
     muzzle.charactersSuppressed = 0;
     muzzle.milliseconds = time;
 
-    const muzzleFromDb = await getRepository(Muzzle).save(muzzle);
+    const muzzleFromDb = await getRepository(Muzzle)
+      .save(muzzle)
+      .catch((e) => {
+        logError(this.logger, 'Failed to create muzzle', e, {
+          requestorId,
+          muzzledId,
+          teamId,
+          time,
+          defensiveItemId,
+        });
+        throw e;
+      });
     const expireTime = Math.floor(time / 1000);
     await this.redis.setValueWithExpire(
       this.getRedisKeyName(muzzledId, teamId, MuzzleRedisTypeEnum.Muzzled),
diff --git a/packages/backend/src/portfolio/portfolio.controller.ts b/packages/backend/src/portfolio/portfolio.controller.ts
index 5f6232ec..d646d95b 100644
--- a/packages/backend/src/portfolio/portfolio.controller.ts
+++ b/packages/backend/src/portfolio/portfolio.controller.ts
@@ -6,12 +6,13 @@ import { textMiddleware } from '../shared/middleware/textMiddleware';
 import { PortfolioService } from './portfolio.service';
 import { TransactionType } from './portfolio.persistence.service';
 import { WebService } from '../shared/services/web/web.service';
+import { logError } from '../shared/logger/error-logging';
 import { logger as loglib } from '../shared/logger/logger';
 import Decimal from 'decimal.js';
 
 export const portfolioController: Router = express.Router();
 
-const logger = loglib.child('PortfolioController');
+const logger = loglib.child({ module: 'PortfolioController' });
 
 const portfolioService = new PortfolioService();
 const webService = new WebService();
@@ -33,6 +34,15 @@ portfolioController.post('/buy', suppressedMiddleware, textMiddleware, (req, res
       } else {
         void webService.sendEphemeral(request.channel_id, response.message, request.user_id);
       }
+    })
+    .catch((e) => {
+      logError(logger, 'Failed to process portfolio buy transaction', e, {
+        userId: request.user_id,
+        teamId: request.team_id,
+        channelId: request.channel_id,
+        symbol: request.text.split(' ')[0]?.toUpperCase(),
+        quantity: parseInt(request.text.split(' ')[1], 10),
+      });
     });
 });
 
@@ -53,39 +63,63 @@ portfolioController.post('/sell', suppressedMiddleware, textMiddleware, (req, re
       } else {
         void webService.sendEphemeral(request.channel_id, response.message, request.user_id);
       }
+    })
+    .catch((e) => {
+      logError(logger, 'Failed to process portfolio sell transaction', e, {
+        userId: request.user_id,
+        teamId: request.team_id,
+        channelId: request.channel_id,
+        symbol: request.text.split(' ')[0]?.toUpperCase(),
+        quantity: parseInt(request.text.split(' ')[1], 10),
+      });
     });
 });
 
 portfolioController.post('/summary', (req, res) => {
   const request: SlashCommandRequest = req.body;
   res.status(200).send();
-  void portfolioService.getPortfolioSummaryWithQuotes(request.user_id, request.team_id).then((summary) => {
-    let message = `*<@${request.user_id}>'s Portfolio Summary:*\n`;
-    logger.info('Portfolio Summary:', summary);
-    summary.summary.forEach((item) => {
-      const currentValue = item.quantity.mul(item.currentPrice);
-      const deltaText = item.costBasis ? `*Gain/Loss:* $${currentValue.minus(item.costBasis).toFixed(2)}` : '';
-      message += `• *${item.symbol}*: \n`;
-      message += `*Value:* $${currentValue.toFixed(2)} (${item.quantity.toFixed(2)} shares @ $${item.currentPrice.toFixed(2)}) \n`;
-      message += `${deltaText} \n`;
-      if (item.costBasis) {
-        message += `*Cost Basis:* $${item.costBasis.toFixed(2)}`;
-      }
-      message += `\n`;
-    });
+  void portfolioService
+    .getPortfolioSummaryWithQuotes(request.user_id, request.team_id)
+    .then((summary) => {
+      let message = `*<@${request.user_id}>'s Portfolio Summary:*\n`;
+      logger.info('Portfolio summary generated', {
+        context: {
+          userId: request.user_id,
+          teamId: request.team_id,
+          positions: summary.summary.length,
+        },
+      });
+      summary.summary.forEach((item) => {
+        const currentValue = item.quantity.mul(item.currentPrice);
+        const deltaText = item.costBasis ? `*Gain/Loss:* $${currentValue.minus(item.costBasis).toFixed(2)}` : '';
+        message += `• *${item.symbol}*: \n`;
+        message += `*Value:* $${currentValue.toFixed(2)} (${item.quantity.toFixed(2)} shares @ $${item.currentPrice.toFixed(2)}) \n`;
+        message += `${deltaText} \n`;
+        if (item.costBasis) {
+          message += `*Cost Basis:* $${item.costBasis.toFixed(2)}`;
+        }
+        message += `\n`;
+      });
 
-    const unrealizedGains = summary.summary.reduce((total, item) => {
-      const currentValue = item.quantity.mul(item.currentPrice);
-      return total.plus(currentValue.minus(item.costBasis || 0));
-    }, new Decimal(0));
+      const unrealizedGains = summary.summary.reduce((total, item) => {
+        const currentValue = item.quantity.mul(item.currentPrice);
+        return total.plus(currentValue.minus(item.costBasis || 0));
+      }, new Decimal(0));
 
-    message += `\n\n*Total Portfolio Balance:* $${summary.summary
-      .reduce((total, item) => {
-        return total.plus(item.quantity.mul(item.currentPrice));
-      }, new Decimal(0))
-      .toFixed(2)}\n`;
-    message += `*Unrealized Gains:* $${unrealizedGains.toFixed(2)}\n`;
-    message += `*Total Dollars Available:* $${summary.rep.totalRepAvailable.toFixed(2)}\n`;
-    void webService.sendEphemeral(request.channel_id, message, request.user_id);
-  });
+      message += `\n\n*Total Portfolio Balance:* $${summary.summary
+        .reduce((total, item) => {
+          return total.plus(item.quantity.mul(item.currentPrice));
+        }, new Decimal(0))
+        .toFixed(2)}\n`;
+      message += `*Unrealized Gains:* $${unrealizedGains.toFixed(2)}\n`;
+      message += `*Total Dollars Available:* $${summary.rep.totalRepAvailable.toFixed(2)}\n`;
+      void webService.sendEphemeral(request.channel_id, message, request.user_id);
+    })
+    .catch((e) => {
+      logError(logger, 'Failed to generate portfolio summary', e, {
+        userId: request.user_id,
+        teamId: request.team_id,
+        channelId: request.channel_id,
+      });
+    });
 });
diff --git a/packages/backend/src/portfolio/portfolio.persistence.service.ts b/packages/backend/src/portfolio/portfolio.persistence.service.ts
index 8ed4a593..9f5113c4 100644
--- a/packages/backend/src/portfolio/portfolio.persistence.service.ts
+++ b/packages/backend/src/portfolio/portfolio.persistence.service.ts
@@ -6,6 +6,7 @@ import { SlackUser } from '../shared/db/models/SlackUser';
 import { ReactionPersistenceService } from '../reaction/reaction.persistence.service';
 import type { TotalRep } from '../reaction/reaction.interface';
 import Decimal from 'decimal.js';
+import { logError } from '../shared/logger/error-logging';
 import { logger as loglib } from '../shared/logger/logger';
 
 export interface PortfolioSummaryItem {
@@ -27,7 +28,7 @@ export enum TransactionType {
 
 export class PortfolioPersistenceService {
   reactionPersistenceService = new ReactionPersistenceService();
-  logger = loglib.child('PortfolioPersistenceService');
+  logger = loglib.child({ module: 'PortfolioPersistenceService' });
 
   public async getPortfolio(userId: string, teamId: string): Promise<Portfolio> {
     const userRepo = getRepository(SlackUser);
@@ -122,6 +123,15 @@ export class PortfolioPersistenceService {
       } catch (error) {
         // Make sure to release the lock in case of error
         await transactionalEntityManager.query('SELECT RELEASE_LOCK(?)', [lockName]);
+        logError(this.logger, 'Portfolio transaction failed inside database transaction', error, {
+          userId,
+          teamId,
+          type,
+          stockSymbol,
+          quantity,
+          price,
+          lockName,
+        });
         throw error;
       }
     });
diff --git a/packages/backend/src/portfolio/portfolio.service.ts b/packages/backend/src/portfolio/portfolio.service.ts
index feac116c..b9dd3df0 100644
--- a/packages/backend/src/portfolio/portfolio.service.ts
+++ b/packages/backend/src/portfolio/portfolio.service.ts
@@ -4,6 +4,7 @@ import { QuoteService } from '../quote/quote.service';
 import { ReactionPersistenceService } from '../reaction/reaction.persistence.service';
 import type { PortfolioSummary, PortfolioSummaryItem } from './portfolio.persistence.service';
 import { PortfolioPersistenceService, TransactionType } from './portfolio.persistence.service';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export enum MessageHandlerEnum {
@@ -32,7 +33,7 @@ export class PortfolioService {
   quoteService = new QuoteService();
   repPersistenceService = new ReactionPersistenceService();
   portfolioPersistenceService = new PortfolioPersistenceService();
-  logger = logger.child('PortfolioService');
+  logger = logger.child({ module: 'PortfolioService' });
 
   public getQuotesWithTicker(portfolioSummaryItem: PortfolioSummaryItem[]): Promise<QuoteWithTicker[]> {
     return Promise.all(
@@ -166,6 +167,13 @@ export class PortfolioService {
       const { c } = await this.quoteService.getQuote(stockSymbol);
       price = c;
     } catch (e) {
+      logError(this.logger, 'Failed to retrieve quote before portfolio transaction', e, {
+        userId,
+        teamId,
+        stockSymbol,
+        quantity,
+        action,
+      });
       return {
         message: `Unable to retrieve price for \`${stockSymbol}\`. Transaction aborted.`,
         classification: MessageHandlerEnum.PRIVATE,
@@ -204,6 +212,13 @@ export class PortfolioService {
             };
           })
           .catch((e) => {
+            logError(this.logger, 'Portfolio buy transaction failed', e, {
+              userId,
+              teamId,
+              stockSymbol,
+              quantity,
+              price,
+            });
             return {
               message: `Transaction failed due to an error: ${e.message}`,
               classification: MessageHandlerEnum.PRIVATE,
@@ -267,6 +282,13 @@ export class PortfolioService {
             };
           })
           .catch((e) => {
+            logError(this.logger, 'Portfolio sell transaction failed', e, {
+              userId,
+              teamId,
+              stockSymbol,
+              quantity,
+              price,
+            });
             return {
               message: `Transaction failed due to an error: ${e.message}`,
               classification: MessageHandlerEnum.PRIVATE,
diff --git a/packages/backend/src/quote/quote.controller.ts b/packages/backend/src/quote/quote.controller.ts
index e996aff2..0f0348c3 100644
--- a/packages/backend/src/quote/quote.controller.ts
+++ b/packages/backend/src/quote/quote.controller.ts
@@ -4,15 +4,24 @@ import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { QuoteService } from './quote.service';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
 import { textMiddleware } from '../shared/middleware/textMiddleware';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export const quoteController: Router = express.Router();
 quoteController.use(suppressedMiddleware);
 quoteController.use(textMiddleware);
 
 const quoteService = new QuoteService();
+const quoteLogger = logger.child({ module: 'QuoteController' });
 
 quoteController.post('/', (req, res) => {
   const request: SlashCommandRequest = req.body;
   res.status(200).send();
-  void quoteService.quote(request.text.toUpperCase(), request.channel_id, request.user_id);
+  void quoteService.quote(request.text.toUpperCase(), request.channel_id, request.user_id).catch((e) => {
+    logError(quoteLogger, 'Failed to handle /quote request', e, {
+      ticker: request.text.toUpperCase(),
+      channelId: request.channel_id,
+      userId: request.user_id,
+    });
+  });
 });
diff --git a/packages/backend/src/quote/quote.service.ts b/packages/backend/src/quote/quote.service.ts
index f1eb4f9e..a9d0e59f 100644
--- a/packages/backend/src/quote/quote.service.ts
+++ b/packages/backend/src/quote/quote.service.ts
@@ -1,6 +1,7 @@
 import Axios from 'axios';
 import type { CompanyProfile, MetricResponse, QuoteData, QuoteResponse } from './quote.models';
 import type { Block, KnownBlock } from '@slack/web-api';
+import { logError } from '../shared/logger/error-logging';
 import { WebService } from '../shared/services/web/web.service';
 import { logger } from '../shared/logger/logger';
 
@@ -42,7 +43,11 @@ export class QuoteService {
       })
       .then((quoteData) => {
         this.webService.sendMessage(channelId, '', this.createQuoteBlocks(quoteData, userId)).catch((e) => {
-          this.logger.error(e);
+          logError(this.logger, 'Failed to send quote response to Slack', e, {
+            ticker,
+            channelId,
+            userId,
+          });
           void this.webService.sendMessage(
             userId,
             'Sorry, unable to send the requested text to Slack. You have been credited for your Moon Token. Perhaps you were trying to send in a private channel? If so, invite @MoonBeam and try again.',
@@ -50,7 +55,11 @@ export class QuoteService {
         });
       })
       .catch((e) => {
-        this.logger.error(e);
+        logError(this.logger, 'Failed to fetch quote data', e, {
+          ticker,
+          channelId,
+          userId,
+        });
         void this.webService.sendMessage(
           userId,
           'Sorry, something went wrong while fetching the quote. Please try again later.',
diff --git a/packages/backend/src/reaction/reaction.controller.ts b/packages/backend/src/reaction/reaction.controller.ts
index 13b4ec32..5b1140f6 100644
--- a/packages/backend/src/reaction/reaction.controller.ts
+++ b/packages/backend/src/reaction/reaction.controller.ts
@@ -3,6 +3,7 @@ import express from 'express';
 import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { ReactionReportService } from './reaction.report.service';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export const reactionController: Router = express.Router();
@@ -17,7 +18,10 @@ reactionController.post('/get', (req, res) => {
     .getRep(request.user_id, request.team_id)
     .then((repValue) => res.send(repValue))
     .catch((e: unknown) => {
-      reactionLogger.error(e);
+      logError(reactionLogger, 'Failed to retrieve reaction report', e, {
+        userId: request.user_id,
+        teamId: request.team_id,
+      });
       res.status(500).send('Internal server error');
     });
 });
diff --git a/packages/backend/src/reaction/reaction.persistence.service.ts b/packages/backend/src/reaction/reaction.persistence.service.ts
index c7e4efff..e64a5735 100644
--- a/packages/backend/src/reaction/reaction.persistence.service.ts
+++ b/packages/backend/src/reaction/reaction.persistence.service.ts
@@ -8,10 +8,11 @@ import { SlackUser } from '../shared/db/models/SlackUser';
 import type { ReactionByUser } from '../shared/models/reaction/ReactionByUser.model';
 import type { Event } from '../shared/models/slack/slack-models';
 import { PortfolioTransactions } from '../shared/db/models/PortfolioTransaction';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 export class ReactionPersistenceService {
-  customLogger = logger.child('ReactionPersistenceService');
+  customLogger = logger.child({ module: 'ReactionPersistenceService' });
 
   public saveReaction(event: Event, value: number, teamId: string): Promise<Reaction> {
     const reaction = new Reaction();
@@ -23,7 +24,19 @@ export class ReactionPersistenceService {
     reaction.channel = event.item.channel;
     reaction.teamId = teamId;
 
-    return getRepository(Reaction).save(reaction);
+    return getRepository(Reaction)
+      .save(reaction)
+      .catch((e) => {
+        logError(this.customLogger, 'Failed to save reaction', e, {
+          reaction: event.reaction,
+          value,
+          teamId,
+          reactingUser: event.user,
+          affectedUser: event.item_user,
+          channelId: event.item.channel,
+        });
+        throw e;
+      });
   }
 
   public async removeReaction(event: Event, teamId: string): Promise<void> {
@@ -36,7 +49,16 @@ export class ReactionPersistenceService {
         channel: event.item.channel,
         teamId: teamId,
       })
-      .catch((e) => e);
+      .catch((e) => {
+        logError(this.customLogger, 'Failed to remove reaction', e, {
+          reaction: event.reaction,
+          teamId,
+          reactingUser: event.user,
+          affectedUser: event.item_user,
+          channelId: event.item.channel,
+        });
+        throw e;
+      });
   }
 
   public async getTotalRep(userId: string, teamId: string): Promise<TotalRep> {
@@ -148,7 +170,11 @@ export class ReactionPersistenceService {
       )
       .then((value) => value)
       .catch((e) => {
-        throw new Error(e);
+        logError(this.customLogger, 'Failed to retrieve reaction report by user', e, {
+          userId,
+          teamId,
+        });
+        throw new Error(e instanceof Error ? e.message : String(e));
       });
   }
 }
diff --git a/packages/backend/src/reaction/reaction.service.spec.ts b/packages/backend/src/reaction/reaction.service.spec.ts
index 509541b1..095483f8 100644
--- a/packages/backend/src/reaction/reaction.service.spec.ts
+++ b/packages/backend/src/reaction/reaction.service.spec.ts
@@ -65,11 +65,23 @@ describe('ReactionService', () => {
     saveReaction.mockRejectedValue(err);
 
     service.handle({
-      event: { type: 'reaction_added', user: 'U1', item_user: 'U2', reaction: '+1' },
+      event: { type: 'reaction_added', user: 'U1', item_user: 'U2', reaction: '+1', item: { channel: 'C1' } },
       team_id: 'T1',
     } as EventRequest);
     await Promise.resolve();
 
-    expect(loggerSpy).toHaveBeenCalledWith(err);
+    expect(loggerSpy).toHaveBeenCalledWith(
+      'Failed to persist added reaction',
+      expect.objectContaining({
+        context: expect.objectContaining({
+          reaction: '+1',
+          reactingUser: 'U1',
+          affectedUser: 'U2',
+          teamId: 'T1',
+          channelId: 'C1',
+        }),
+        error: expect.objectContaining({ message: 'db error', name: 'Error' }),
+      }),
+    );
   });
 });
diff --git a/packages/backend/src/reaction/reaction.service.ts b/packages/backend/src/reaction/reaction.service.ts
index 4fa8fe5b..9f54302e 100644
--- a/packages/backend/src/reaction/reaction.service.ts
+++ b/packages/backend/src/reaction/reaction.service.ts
@@ -1,5 +1,6 @@
 import { logger } from '../shared/logger/logger';
 import type { Event, EventRequest } from '../shared/models/slack/slack-models';
+import { logError } from '../shared/logger/error-logging';
 import { reactionValues } from './constants';
 import { ReactionPersistenceService } from './reaction.persistence.service';
 
@@ -25,7 +26,15 @@ export class ReactionService {
     const reactionValue = reactionValues[event.reaction];
     // Log event to DB.
     if (this.shouldReactionBeLogged(reactionValue)) {
-      this.reactionPersistenceService.saveReaction(event, reactionValue, teamId).catch((e) => this.logger.error(e));
+      this.reactionPersistenceService.saveReaction(event, reactionValue, teamId).catch((e) =>
+        logError(this.logger, 'Failed to persist added reaction', e, {
+          reaction: event.reaction,
+          reactingUser: event.user,
+          affectedUser: event.item_user,
+          teamId,
+          channelId: event.item.channel,
+        }),
+      );
     }
   }
 
diff --git a/packages/backend/src/shared/logger/error-logging.ts b/packages/backend/src/shared/logger/error-logging.ts
new file mode 100644
index 00000000..fbd333a8
--- /dev/null
+++ b/packages/backend/src/shared/logger/error-logging.ts
@@ -0,0 +1,46 @@
+import type { Logger } from 'winston';
+
+type LoggerLike = Pick<Logger, 'error'> | { error?: (message: string, payload?: Record<string, unknown>) => void };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
+export const serializeError = (error: unknown): Record<string, unknown> => {
+  if (error instanceof Error) {
+    const details = Object.entries(error).reduce<Record<string, unknown>>((accumulator, [key, value]) => {
+      accumulator[key] = value;
+      return accumulator;
+    }, {});
+
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      ...details,
+    };
+  }
+
+  if (isRecord(error)) {
+    return { ...error };
+  }
+
+  return { value: error };
+};
+
+export const logError = (
+  logger: LoggerLike,
+  message: string,
+  error: unknown,
+  context?: Record<string, unknown>,
+): void => {
+  const payload: Record<string, unknown> = {
+    error: serializeError(error),
+  };
+
+  if (context && Object.keys(context).length > 0) {
+    payload.context = context;
+  }
+
+  if (typeof logger.error === 'function') {
+    logger.error(message, payload);
+  }
+};
diff --git a/packages/backend/src/shared/logger/logger.ts b/packages/backend/src/shared/logger/logger.ts
index 50cd70f4..19f287c5 100644
--- a/packages/backend/src/shared/logger/logger.ts
+++ b/packages/backend/src/shared/logger/logger.ts
@@ -1,13 +1,120 @@
 import { createLogger, format, transports } from 'winston';
-const { combine, timestamp, prettyPrint } = format;
+
+const { combine, errors, timestamp, printf } = format;
+const splatSymbol = Symbol.for('splat');
+
+type LogInfo = {
+  level: string;
+  message: unknown;
+  timestamp?: string;
+  module?: string;
+  context?: Record<string, unknown>;
+  error?: unknown;
+  stack?: string;
+  name?: string;
+  [key: string | symbol]: unknown;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
+const serializeError = (error: unknown): Record<string, unknown> => {
+  if (error instanceof Error) {
+    const details = Object.entries(error).reduce<Record<string, unknown>>((accumulator, [key, value]) => {
+      accumulator[key] = value;
+      return accumulator;
+    }, {});
+
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      ...details,
+    };
+  }
+
+  if (isRecord(error)) {
+    return { ...error };
+  }
+
+  return { value: error };
+};
+
+const normalizeLogInfo = format((info: LogInfo) => {
+  const normalizedInfo = info;
+  const splat = normalizedInfo[splatSymbol];
+
+  if (Array.isArray(splat)) {
+    for (const item of splat) {
+      if (item instanceof Error) {
+        normalizedInfo.error = serializeError(item);
+        continue;
+      }
+
+      if (item && typeof item === 'object') {
+        Object.assign(normalizedInfo, item);
+      }
+    }
+  }
+
+  if (normalizedInfo.error !== undefined) {
+    normalizedInfo.error = serializeError(normalizedInfo.error);
+  } else if (normalizedInfo.stack) {
+    normalizedInfo.error = {
+      name: normalizedInfo.name ?? 'Error',
+      message:
+        typeof normalizedInfo.message === 'string' ? normalizedInfo.message : JSON.stringify(normalizedInfo.message),
+      stack: normalizedInfo.stack,
+    };
+  }
+
+  return normalizedInfo;
+});
+
+const jsonLineFormat = printf((info: LogInfo) => {
+  const { level, message, timestamp: loggedAt, module, context, error, stack, name, ...rest } = info;
+
+  const meta = Object.entries(rest).reduce<Record<string, unknown>>((accumulator, [key, value]) => {
+    if (key === 'level' || key === 'message' || key === 'timestamp' || key === 'module' || key === 'context') {
+      return accumulator;
+    }
+
+    accumulator[key] = value;
+    return accumulator;
+  }, {});
+
+  const payload: Record<string, unknown> = {
+    timestamp: loggedAt,
+    level,
+    module,
+    message: typeof message === 'string' ? message : JSON.stringify(message),
+  };
+
+  if (context && Object.keys(context).length > 0) {
+    payload.context = context;
+  }
+
+  if (error) {
+    payload.error = error;
+  }
+
+  if (!error && stack) {
+    payload.error = {
+      name: name ?? 'Error',
+      message: payload.message,
+      stack,
+    };
+  }
+
+  if (Object.keys(meta).length > 0) {
+    payload.meta = meta;
+  }
+
+  return JSON.stringify(payload);
+});
 
 export const logger = createLogger({
   level: 'info',
-  format: combine(timestamp(), prettyPrint()),
+  format: combine(errors({ stack: true }), timestamp(), normalizeLogInfo(), jsonLineFormat),
   defaultMeta: {},
-  transports: [
-    new transports.Console(),
-    new transports.File({ filename: 'error.log', level: 'error' }),
-    new transports.File({ filename: 'combined.log' }),
-  ],
+  transports: [new transports.Console()],
 });
diff --git a/packages/backend/src/shared/services/history.persistence.service.ts b/packages/backend/src/shared/services/history.persistence.service.ts
index 433f32bb..a6e02633 100644
--- a/packages/backend/src/shared/services/history.persistence.service.ts
+++ b/packages/backend/src/shared/services/history.persistence.service.ts
@@ -4,6 +4,8 @@ import { SlackUser } from '../db/models/SlackUser';
 import type { EventRequest, SlashCommandRequest } from '../models/slack/slack-models';
 import { Message } from '../db/models/Message';
 import type { MessageWithName } from '../models/message/message-with-name';
+import { logError } from '../logger/error-logging';
+import { logger } from '../logger/logger';
 
 export interface HistoryOptions {
   teamId: string;
@@ -14,6 +16,8 @@ export interface HistoryOptions {
 }
 
 export class HistoryPersistenceService {
+  private logger = logger.child({ module: 'HistoryPersistenceService' });
+
   async logHistory(request: EventRequest): Promise<InsertResult | undefined> {
     // This is a bandaid to stop workflows from breaking the service.
     if (typeof request.event.user !== 'string' || request.event.type === 'user_profile_changed') {
@@ -34,7 +38,17 @@ export class HistoryPersistenceService {
     message.teamId = request.team_id;
     message.userId = user;
     message.message = request.event.text;
-    return getRepository(Message).insert(message);
+    return getRepository(Message)
+      .insert(message)
+      .catch((e) => {
+        logError(this.logger, 'Failed to persist message history', e, {
+          eventType: request.event.type,
+          teamId: request.team_id,
+          userId: request.event.user,
+          channelId: message.channel,
+        });
+        throw e;
+      });
   }
 
   async getLastFiveMinutesCount(teamId: string, channelId: string): Promise<number> {
@@ -69,7 +83,16 @@ export class HistoryPersistenceService {
     ORDER BY createdAt DESC
   ) ORDER BY createdAt ASC;`;
 
-    return getRepository(Message).query(query, [teamId, channel, teamId, channel]);
+    return getRepository(Message)
+      .query(query, [teamId, channel, teamId, channel])
+      .catch((e) => {
+        logError(this.logger, 'Failed to retrieve message history', e, {
+          teamId,
+          channelId: channel,
+          isDaily,
+        });
+        throw e;
+      });
   }
 
   /**
@@ -101,6 +124,17 @@ export class HistoryPersistenceService {
       ORDER BY createdAt DESC
     ) ORDER BY createdAt ASC;`;
 
-    return getRepository(Message).query(query, [teamId, channelId, maxMessages, teamId, channelId, timeWindowMinutes]);
+    return getRepository(Message)
+      .query(query, [teamId, channelId, maxMessages, teamId, channelId, timeWindowMinutes])
+      .catch((e) => {
+        logError(this.logger, 'Failed to retrieve message history with options', e, {
+          teamId,
+          channelId,
+          maxMessages,
+          timeWindowMinutes,
+          excludeUserId,
+        });
+        throw e;
+      });
   }
 }
diff --git a/packages/backend/src/shared/services/slack/slack.persistence.service.ts b/packages/backend/src/shared/services/slack/slack.persistence.service.ts
index a0f861f5..c82b426e 100644
--- a/packages/backend/src/shared/services/slack/slack.persistence.service.ts
+++ b/packages/backend/src/shared/services/slack/slack.persistence.service.ts
@@ -4,6 +4,7 @@ import type { SlackUser as SlackUserModel } from '../../../shared/models/slack/s
 import { SlackUser as SlackUserFromDB } from '../../../shared/db/models/SlackUser';
 import { RedisPersistenceService } from '../../../shared/services/redis.persistence.service';
 import type { ConversationsListResponse } from '@slack/web-api';
+import { logError } from '../../logger/error-logging';
 import { logger } from '../../logger/logger';
 
 type SlackUserForStorage = Pick<SlackUserModel, 'id' | 'name'> &
@@ -50,7 +51,9 @@ export class SlackPersistenceService {
         }
         this.logger.info('Updated channel list');
       } catch (e) {
-        this.logger.error('Error on updating channels: ', e);
+        logError(this.logger, 'Error updating channels', e, {
+          channelCount: dbChannels.length,
+        });
       }
     }
   }
@@ -92,20 +95,28 @@ export class SlackPersistenceService {
           await getRepository(SlackUserFromDB)
             .save({ ...existingUser, user })
             .catch((e) => {
-              this.logger.error('Error updating user: ', e);
+              logError(this.logger, 'Error updating user', e, {
+                slackId: user.slackId,
+                teamId: user.teamId,
+              });
             });
         } else {
           await getRepository(SlackUserFromDB)
             .save({ ...user, activity: [], messages: [] })
             .catch((e) => {
-              this.logger.error('Error saving user: ', e);
+              logError(this.logger, 'Error saving user', e, {
+                slackId: user.slackId,
+                teamId: user.teamId,
+              });
             });
         }
       }
       this.logger.info('Updated latest users in DB.');
       return dbUsers;
     } catch (e) {
-      this.logger.error('Error on updating users: ', e);
+      logError(this.logger, 'Error updating users', e, {
+        userCount: dbUsers.length,
+      });
       throw e;
     }
   }
diff --git a/packages/backend/src/shared/services/slack/slack.service.spec.ts b/packages/backend/src/shared/services/slack/slack.service.spec.ts
index 22449233..9a7646cb 100644
--- a/packages/backend/src/shared/services/slack/slack.service.spec.ts
+++ b/packages/backend/src/shared/services/slack/slack.service.spec.ts
@@ -306,7 +306,17 @@ describe('SlackService', () => {
       const postPromise = mockPost.mock.results[0]?.value as Promise<unknown>;
       await postPromise.catch(() => undefined);
       expect(mockPost).toHaveBeenCalled();
-      expect(loggerSpy).toHaveBeenCalledWith(expect.stringContaining('Error responding'));
+      expect(loggerSpy).toHaveBeenCalledWith(
+        'Failed to post Slack response URL callback',
+        expect.objectContaining({
+          context: expect.objectContaining({
+            responseUrl: 'https://hooks.slack.com/test',
+            responseType: 'in_channel',
+            responseText: 'test',
+          }),
+          error: expect.objectContaining({ message: 'Network error', name: 'Error' }),
+        }),
+      );
     });
   });
 
@@ -392,7 +402,12 @@ describe('SlackService', () => {
       const promise = slackService.getAllUsers();
 
       await expect(promise).rejects.toThrow('Unable to retrieve users');
-      expect(loggerSpy).toHaveBeenCalledWith('Failed to retrieve users', expect.any(Error));
+      expect(loggerSpy).toHaveBeenCalledWith(
+        'Failed to retrieve users',
+        expect.objectContaining({
+          error: expect.objectContaining({ message: 'API Error', name: 'Error' }),
+        }),
+      );
 
       jest.useRealTimers();
     });
@@ -489,7 +504,13 @@ describe('SlackService', () => {
       } as unknown as EventRequest);
 
       await new Promise((resolve) => setTimeout(resolve, 100));
-      expect(loggerSpy).toHaveBeenCalledWith('Error handling team join event:', expect.any(Error));
+      expect(loggerSpy).toHaveBeenCalledWith(
+        'Error handling team join event',
+        expect.objectContaining({
+          context: expect.objectContaining({ eventType: 'team_join' }),
+          error: expect.objectContaining({ message: 'API Error', name: 'Error' }),
+        }),
+      );
     });
   });
 
diff --git a/packages/backend/src/shared/services/slack/slack.service.ts b/packages/backend/src/shared/services/slack/slack.service.ts
index c80cf5ad..c5aec7d2 100644
--- a/packages/backend/src/shared/services/slack/slack.service.ts
+++ b/packages/backend/src/shared/services/slack/slack.service.ts
@@ -4,6 +4,7 @@ import { USER_ID_REGEX } from './constants';
 import { SlackPersistenceService } from './slack.persistence.service';
 import type { ChannelResponse, EventRequest } from '../../models/slack/slack-models';
 import type { SlackUser as SlackUserFromDB } from '../../db/models/SlackUser';
+import { logError } from '../../logger/error-logging';
 import { logger } from '../../logger/logger';
 
 interface ImpersonationCandidate {
@@ -87,9 +88,13 @@ export class SlackService {
   logger = logger.child({ module: 'SlackService' });
 
   public sendResponse(responseUrl: string, response: ChannelResponse): void {
-    axios
-      .post(encodeURI(responseUrl), response)
-      .catch((e: Error) => this.logger.error(`Error responding: ${e.message} at ${responseUrl}`));
+    axios.post(encodeURI(responseUrl), response).catch((e: Error) =>
+      logError(this.logger, 'Failed to post Slack response URL callback', e, {
+        responseUrl,
+        responseType: response.response_type,
+        responseText: response.text,
+      }),
+    );
   }
 
   /**
@@ -218,7 +223,7 @@ export class SlackService {
       response = await this.web.getAllUsers();
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
-      this.logger.error('Failed to retrieve users', e);
+      logError(this.logger, 'Failed to retrieve users', e);
       this.logger.warn('Retrying in 60 seconds...');
       setTimeout(() => {
         void this.getAllUsers();
@@ -241,7 +246,12 @@ export class SlackService {
 
   public handle(request: EventRequest): void {
     if (request.event.type === 'team_join') {
-      this.getAllUsers().catch((e) => this.logger.error('Error handling team join event:', e));
+      this.getAllUsers().catch((e) =>
+        logError(this.logger, 'Error handling team join event', e, {
+          eventType: request.event.type,
+          userId: typeof request.event.user === 'string' ? request.event.user : undefined,
+        }),
+      );
     } else if (request.event.type === 'channel_created') {
       this.getAndSaveAllChannels();
     }
diff --git a/packages/backend/src/shared/services/web/web.service.ts b/packages/backend/src/shared/services/web/web.service.ts
index 6066e267..020f857d 100644
--- a/packages/backend/src/shared/services/web/web.service.ts
+++ b/packages/backend/src/shared/services/web/web.service.ts
@@ -11,6 +11,7 @@ import type {
   UsersListResponse,
 } from '@slack/web-api';
 import { WebClient } from '@slack/web-api';
+import { logError } from '../../logger/error-logging';
 import { logger } from '../../logger/logger';
 
 const MAX_RETRIES = 5;
@@ -52,18 +53,25 @@ export class WebService {
       .delete(deleteRequest)
       .then((r) => {
         if (r.error) {
-          this.logger.error(r.error);
-          this.logger.error(deleteRequest);
-          this.logger.error(user);
+          logError(this.logger, 'Slack deleteMessage returned an API error', new Error(r.error), {
+            channel,
+            ts,
+            user,
+            deleteRequest,
+          });
         }
       })
       .catch((e) => {
-        this.logger.error(e);
-        if (e.data.error !== 'message_not_found') {
-          this.logger.error(e);
-          this.logger.error('delete request was : ');
-          this.logger.error(deleteRequest);
-          this.logger.error('Unable to delete message. Retrying in 5 seconds...');
+        const errorCode = getSlackErrorCode(e);
+        if (errorCode !== 'message_not_found') {
+          logError(this.logger, 'Failed to delete Slack message; scheduling retry', e, {
+            channel,
+            ts,
+            user,
+            times,
+            deleteRequest,
+            errorCode,
+          });
           setTimeout(() => this.deleteMessage(channel, ts, user, times + 1), 5000);
         }
       });
@@ -81,8 +89,12 @@ export class WebService {
       .postEphemeral(postRequest)
       .then((result) => result)
       .catch((e) => {
-        this.logger.error(e);
-        this.logger.error(postRequest);
+        logError(this.logger, 'Failed to send ephemeral Slack message', e, {
+          channel,
+          user,
+          text,
+          postRequest,
+        });
         return e;
       });
   }
@@ -104,9 +116,13 @@ export class WebService {
       .postMessage(postRequest)
       .then((result) => result)
       .catch((e) => {
-        this.logger.error(e);
-        this.logger.error(e.data);
-        this.logger.error(postRequest);
+        logError(this.logger, 'Failed to send Slack message', e, {
+          channel,
+          text,
+          hasBlocks: !!blocks?.length,
+          postRequest,
+          errorCode: getSlackErrorCode(e),
+        });
         throw e;
       });
   }
@@ -119,7 +135,13 @@ export class WebService {
       ts,
       token,
     };
-    this.web.chat.update(update).catch((e) => this.logger.error(e));
+    this.web.chat.update(update).catch((e) =>
+      logError(this.logger, 'Failed to edit Slack message', e, {
+        channel,
+        ts,
+        text,
+      }),
+    );
   }
 
   public getAllUsers(): Promise<UsersListResponse> {
@@ -148,8 +170,13 @@ export class WebService {
     };
 
     this.web.files.upload(uploadRequest).catch((e: unknown) => {
-      this.logger.error(e);
       const slackErrorCode = getSlackErrorCode(e);
+      logError(this.logger, 'Failed to upload Slack file', e, {
+        channel,
+        title,
+        userId,
+        errorCode: slackErrorCode,
+      });
       const options: ChatPostEphemeralArguments = {
         channel,
         text:
@@ -158,7 +185,13 @@ export class WebService {
             : `Oops! I tried to post the stats you requested but it looks like something went wrong. Please try again later.`,
         user: userId,
       };
-      this.web.chat.postEphemeral(options).catch((e) => this.logger.error(e));
+      this.web.chat.postEphemeral(options).catch((e) =>
+        logError(this.logger, 'Failed to send fallback ephemeral after upload failure', e, {
+          channel,
+          userId,
+          title,
+        }),
+      );
     });
   }
 }
diff --git a/packages/backend/src/store/item.service.ts b/packages/backend/src/store/item.service.ts
index fa4a079e..71b235f5 100644
--- a/packages/backend/src/store/item.service.ts
+++ b/packages/backend/src/store/item.service.ts
@@ -1,5 +1,6 @@
 import { WebService } from '../shared/services/web/web.service';
 import { SuppressorService } from '../shared/services/suppressor.service';
+import { logError } from '../shared/logger/error-logging';
 import { StoreService } from './store.service';
 import { logger } from '../shared/logger/logger';
 
@@ -19,7 +20,12 @@ export class ItemService {
       id: 1,
       interaction: (userId, teamId, usedOnUser): Promise<string> => {
         return this.storeService.useItem('1', userId, teamId, usedOnUser).catch((e) => {
-          this.logger.error(e);
+          logError(this.logger, 'Failed to activate 50 Cal item', e, {
+            userId,
+            teamId,
+            usedOnUser,
+            itemId: '1',
+          });
           throw new Error(`Sorry, unable to set 50 Cal at this time. Please try again later.`);
         });
       },
@@ -28,7 +34,12 @@ export class ItemService {
       id: 2,
       interaction: (userId, teamId, usedOnUser): Promise<string> => {
         return this.storeService.useItem('2', userId, teamId, usedOnUser).catch((e) => {
-          this.logger.error(e);
+          logError(this.logger, 'Failed to activate Guardian Angel item', e, {
+            userId,
+            teamId,
+            usedOnUser,
+            itemId: '2',
+          });
           throw new Error(
             `Sorry, unable to set Guardian Angel on <@${usedOnUser}> at this time. Please try again later.`,
           );
@@ -47,7 +58,13 @@ export class ItemService {
           await this.webService
             .sendMessage(channel, `:zombie: <@${usedOnUser}> has been resurrected by <@${userId}>! :zombie:`)
             .catch((e) => {
-              this.logger.error(e);
+              logError(this.logger, 'Failed to send resurrection message', e, {
+                userId,
+                teamId,
+                usedOnUser,
+                channel,
+                itemId: '3',
+              });
               throw new Error(`Unable to resurrect <@${usedOnUser}>. Please try again.`);
             });
           return this.storeService.useItem('3', userId, teamId, usedOnUser);
@@ -64,7 +81,12 @@ export class ItemService {
           throw new Error(`Sorry, unable to purchase Moon Token at this time. You already have one active.`);
         }
         return this.storeService.useItem('4', userId, teamId, usedOnUser).catch((e) => {
-          this.logger.error(e);
+          logError(this.logger, 'Failed to activate Moon Token item', e, {
+            userId,
+            teamId,
+            usedOnUser,
+            itemId: '4',
+          });
           throw new Error(`Sorry, unable to purchase Moon Token at this time. Please try again later.`);
         });
       },
diff --git a/packages/backend/src/store/store.controller.ts b/packages/backend/src/store/store.controller.ts
index b7c8bcec..ea1d282c 100644
--- a/packages/backend/src/store/store.controller.ts
+++ b/packages/backend/src/store/store.controller.ts
@@ -4,6 +4,7 @@ import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { StoreService } from './store.service';
 import { SuppressorService } from '../shared/services/suppressor.service';
 import { ItemService } from './item.service';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
 
@@ -22,7 +23,10 @@ storeController.post('/', (req, res) => {
     .listItems(request.user_id, request.team_id)
     .then((storeItems) => res.status(200).send(storeItems))
     .catch((e) => {
-      storeLogger.error(e);
+      logError(storeLogger, 'Failed to list store items', e, {
+        userId: request.user_id,
+        teamId: request.team_id,
+      });
       res.status(500).send();
     });
 });
@@ -75,12 +79,12 @@ storeController.post('/use', (req, res) => {
       const useReceipt = await itemService
         .useItem(itemId, request.user_id, request.team_id, targetUserId, request.channel_name)
         .catch((e) => {
-          storeLogger.error(e, {
-            item: itemId,
+          logError(storeLogger, 'Failed to use store item', e, {
+            itemId,
             userId: request.user_id,
             teamId: request.team_id,
-            userIdForItem,
-            channel: request.channel_name,
+            targetUserId: userIdForItem,
+            channelName: request.channel_name,
           });
           res.status(500).send('An unexpected error occurred while using the item.');
           return undefined;
@@ -93,8 +97,8 @@ storeController.post('/use', (req, res) => {
       const purchaseReceipt: string | undefined = await storeService
         .buyItem(itemId, request.user_id, request.team_id)
         .catch((e) => {
-          storeLogger.error(e, {
-            item: itemId,
+          logError(storeLogger, 'Failed to purchase store item after use', e, {
+            itemId,
             userId: request.user_id,
             teamId: request.team_id,
           });
@@ -109,7 +113,11 @@ storeController.post('/use', (req, res) => {
       res.status(200).send(useReceipt);
     }
   })().catch((e: unknown) => {
-    storeLogger.error(e);
+    logError(storeLogger, 'Unhandled error in /store/use controller', e, {
+      requestText: req.body?.text,
+      userId: req.body?.user_id,
+      teamId: req.body?.team_id,
+    });
     res.status(500).send('An unexpected error occurred.');
   });
 });
diff --git a/packages/backend/src/store/store.persistence.service.ts b/packages/backend/src/store/store.persistence.service.ts
index de21db29..f20afb6e 100644
--- a/packages/backend/src/store/store.persistence.service.ts
+++ b/packages/backend/src/store/store.persistence.service.ts
@@ -6,6 +6,7 @@ import { Purchase } from '../shared/db/models/Purchase';
 import { UsedItem } from '../shared/db/models/UsedItem';
 import { ItemKill } from '../shared/db/models/ItemKill';
 import { getMsForSpecifiedRange } from '../muzzle/muzzle-utilities';
+import { logError } from '../shared/logger/error-logging';
 import { logger } from '../shared/logger/logger';
 
 interface ItemWithPrice extends Item {
@@ -128,8 +129,12 @@ export class StorePersistenceService {
         .insert(purchase)
         .then(() => `Congratulations! You have purchased *_${itemById.name}!_*`)
         .catch((e) => {
-          this.logger.error('Error on updating purchase table');
-          this.logger.error(e);
+          logError(this.logger, 'Failed to record store purchase', e, {
+            itemId,
+            itemName: itemById.name,
+            userId,
+            teamId,
+          });
           return `Sorry, unable to buy ${itemById.name}. Please try again later.`;
         });
     }
diff --git a/packages/backend/src/store/store.service.ts b/packages/backend/src/store/store.service.ts
index 277b61be..1ef410cc 100644
--- a/packages/backend/src/store/store.service.ts
+++ b/packages/backend/src/store/store.service.ts
@@ -1,9 +1,12 @@
 import { ReactionPersistenceService } from '../reaction/reaction.persistence.service';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 import { StorePersistenceService } from './store.persistence.service';
 
 export class StoreService {
   storePersistenceService = new StorePersistenceService();
   reactionPersistenceService = new ReactionPersistenceService();
+  logger = logger.child({ module: 'StoreService' });
 
   async listItems(slackId: string, teamId: string): Promise<string> {
     const items = await this.storePersistenceService.getItems(teamId);
@@ -38,7 +41,14 @@ export class StoreService {
 
   buyItem(itemId: string, userId: string, teamId: string): Promise<string> {
     const id = +itemId;
-    return this.storePersistenceService.buyItem(id, userId, teamId);
+    return this.storePersistenceService.buyItem(id, userId, teamId).catch((e) => {
+      logError(this.logger, 'Failed to buy store item', e, {
+        itemId,
+        userId,
+        teamId,
+      });
+      throw e;
+    });
   }
 
   async isUserRequired(itemId: string | undefined): Promise<boolean> {
@@ -54,7 +64,15 @@ export class StoreService {
     if (isNaN(id)) {
       return `Sorry, ${itemId} is not a valid item.`;
     }
-    return this.storePersistenceService.useItem(id, userId, teamId, userIdForItem);
+    return this.storePersistenceService.useItem(id, userId, teamId, userIdForItem).catch((e) => {
+      logError(this.logger, 'Failed to use store item', e, {
+        itemId,
+        userId,
+        teamId,
+        targetUserId: userIdForItem,
+      });
+      throw e;
+    });
   }
 
   isItemActive(userId: string, teamId: string, itemId: number): Promise<boolean> {
diff --git a/packages/backend/src/walkie/walkie.controller.ts b/packages/backend/src/walkie/walkie.controller.ts
index 7ebb3b4b..0a0e8cc0 100644
--- a/packages/backend/src/walkie/walkie.controller.ts
+++ b/packages/backend/src/walkie/walkie.controller.ts
@@ -3,15 +3,25 @@ import express from 'express';
 import type { SlashCommandRequest } from '../shared/models/slack/slack-models';
 import { WalkieService } from './walkie.service';
 import { suppressedMiddleware } from '../shared/middleware/suppression';
+import { logError } from '../shared/logger/error-logging';
+import { logger } from '../shared/logger/logger';
 
 export const walkieController: Router = express.Router();
 
 const walkieService = new WalkieService();
+const walkieLogger = logger.child({ module: 'WalkieController' });
 
 walkieController.use(suppressedMiddleware);
 
 walkieController.post('/', (req, res) => {
   const request: SlashCommandRequest = req.body;
-  walkieService.walkieTalkie(request);
+  void Promise.resolve(walkieService.walkieTalkie(request)).catch((e) => {
+    logError(walkieLogger, 'Failed to handle /walkie request', e, {
+      userId: request.user_id,
+      channelId: request.channel_id,
+      responseUrl: request.response_url,
+      text: request.text,
+    });
+  });
   res.status(200).send();
 });
diff --git a/packages/backend/src/walkie/walkie.service.ts b/packages/backend/src/walkie/walkie.service.ts
index 90f1d56b..230f7617 100644
--- a/packages/backend/src/walkie/walkie.service.ts
+++ b/packages/backend/src/walkie/walkie.service.ts
@@ -1,9 +1,11 @@
 import type { ChannelResponse, SlashCommandRequest } from '../shared/models/slack/slack-models';
+import { logger } from '../shared/logger/logger';
 import { SlackService } from '../shared/services/slack/slack.service';
 import { NATO_MAPPINGS, USER_ID_REGEX } from './constants';
 
 export class WalkieService {
   slackService = new SlackService();
+  logger = logger.child({ module: 'WalkieService' });
 
   public getUserId(user: string): string {
     if (!user) {
@@ -18,7 +20,7 @@ export class WalkieService {
     return NATO_MAPPINGS[userId] || longUserId;
   }
 
-  public walkieTalkie(request: SlashCommandRequest): void {
+  public async walkieTalkie(request: SlashCommandRequest): Promise<void> {
     const { text } = request;
     if (!text || text.length === 0) {
       return;