···

       
103
       
103
       
 
       
      },

     

       
104
       
104
       
 
       
    }),

     

       
105
       
105
       
 
       
  )

     

       
106
       
106
       
-
       
  .onError(({ code, error }) => {

     

       
106
       
106
       
+
       
  .onError(({ code, error, request }) => {

     

       
107
       
107
       
 
       
    if (error instanceof Error)

     

       
108
       
108
       
 
       
      console.error(

     

       
109
       
109
       
 
       
        `\x1b[31m x\x1b[0m unhandled error: \x1b[31m${error.message}\x1b[0m`,

     

       
110
       
110
       
 
       
      );

     

       
111
       
111
       
-
       
    Sentry.captureException(error);

     

       
111
       
111
       
+
       
    Sentry.withScope((scope) => {

     

       
112
       
112
       
+
       
      scope.setExtra("url", request.url);

     

       
113
       
113
       
+
       
      scope.setExtra("code", code);

     

       
114
       
114
       
+
       
      Sentry.captureException(error);

     

       
115
       
115
       
+
       
    });

     

       
112
       
116
       
 
       
    if (code === "VALIDATION") {

     

       
113
       
117
       
 
       
      return error.message;

     

       
114
       
118
       
 
       
    }

     
···

       
170
       
174
       
 
       
  )

     

       
171
       
175
       
 
       
  .get(

     

       
172
       
176
       
 
       
    "/users/:user",

     

       
173
       
173
       
-
       
    async ({ params, error }) => {

     

       
177
       
177
       
+
       
    async ({ params, error, request }) => {

     

       
174
       
178
       
 
       
      const user = await cache.getUser(params.user);

     

       
175
       
179
       
 
       


     

       
176
       
180
       
 
       
      // if not found then check slack first

     
···

       
182
       
186
       
 
       
          if (e instanceof Error && e.message === "user_not_found")

     

       
183
       
187
       
 
       
            return error(404, { message: "User not found" });

     

       
184
       
188
       
 
       


     

       
185
       
185
       
-
       
          Sentry.captureException(e);

     

       
189
       
189
       
+
       
          Sentry.withScope((scope) => {

     

       
190
       
190
       
+
       
            scope.setExtra("url", request.url);

     

       
191
       
191
       
+
       
            scope.setExtra("user", params.user);

     

       
192
       
192
       
+
       
            Sentry.captureException(e);

     

       
193
       
193
       
+
       
          });

     

       
186
       
194
       
 
       


     

       
187
       
195
       
 
       
          if (e instanceof Error)

     

       
188
       
196
       
 
       
            console.warn(

     
···

       
247
       
255
       
 
       
  )

     

       
248
       
256
       
 
       
  .get(

     

       
249
       
257
       
 
       
    "/users/:user/r",

     

       
250
       
250
       
-
       
    async ({ params, error, redirect }) => {

     

       
258
       
258
       
+
       
    async ({ params, error, redirect, request }) => {

     

       
251
       
259
       
 
       
      const user = await cache.getUser(params.user);

     

       
252
       
260
       
 
       


     

       
253
       
261
       
 
       
      // if not found then check slack first

     
···

       
259
       
267
       
 
       
          if (e instanceof Error && e.message === "user_not_found")

     

       
260
       
268
       
 
       
            return error(404, { message: "User not found" });

     

       
261
       
269
       
 
       


     

       
262
       
262
       
-
       
          Sentry.captureException(e);

     

       
270
       
270
       
+
       
          Sentry.withScope((scope) => {

     

       
271
       
271
       
+
       
            scope.setExtra("url", request.url);

     

       
272
       
272
       
+
       
            scope.setExtra("user", params.user);

     

       
273
       
273
       
+
       
            Sentry.captureException(e);

     

       
274
       
274
       
+
       
          });

     

       
263
       
275
       
 
       


     

       
264
       
276
       
 
       
          if (e instanceof Error)

     

       
265
       
277
       
 
       
            console.warn(