feat(results): ⚡️ Improve logs details

apps/builder/contexts/UserContext.tsx

@@ -51,7 +51,7 @@ export const UserContext = ({ children }: { children: ReactNode }) => {
     if (isDefined(user) || isNotDefined(session)) return
     const parsedUser = session.user as User
     setUser(parsedUser)
-    setSentryUser({ id: parsedUser.id })
+    if (parsedUser?.id) setSentryUser({ id: parsedUser.id })
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [session])
 

apps/viewer/layouts/TypebotPage.tsx

@@ -1,10 +1,9 @@
 import { TypebotViewer } from 'bot-engine'
-import { Log } from 'db'
 import { Answer, PublicTypebot, VariableWithValue } from 'models'
 import React, { useEffect, useState } from 'react'
 import { upsertAnswer } from 'services/answer'
 import { SEO } from '../components/Seo'
-import { createLog, createResult, updateResult } from '../services/result'
+import { createResult, updateResult } from '../services/result'
 import { ErrorPage } from './ErrorPage'
 
 export type TypebotPageProps = {
@@ -74,14 +73,6 @@ export const TypebotPage = ({
     if (error) setError(error)
   }
 
-  const handleNewLog = async (
-    log: Omit<Log, 'id' | 'createdAt' | 'resultId'>
-  ) => {
-    if (!resultId) return setError(new Error('Result was not created'))
-    const { error } = await createLog(resultId, log)
-    if (error) setError(error)
-  }
-
   if (error) {
     return <ErrorPage error={error} />
   }
@@ -95,11 +86,11 @@ export const TypebotPage = ({
       {showTypebot && (
         <TypebotViewer
           typebot={typebot}
+          resultId={resultId}
           predefinedVariables={predefinedVariables}
           onNewAnswer={handleNewAnswer}
           onCompleted={handleCompleted}
           onVariablesUpdated={handleNewVariables}
-          onNewLog={handleNewLog}
         />
       )}
     </div>

apps/viewer/pages/api/integrations/email.ts

@@ -2,10 +2,11 @@ import prisma from 'libs/prisma'
 import { SendEmailOptions, SmtpCredentialsData } from 'models'
 import { NextApiRequest, NextApiResponse } from 'next'
 import { createTransport, getTestMessageUrl } from 'nodemailer'
-import { decrypt, initMiddleware } from 'utils'
+import { decrypt, initMiddleware, methodNotAllowed } from 'utils'
 
 import Cors from 'cors'
 import { withSentry } from '@sentry/nextjs'
+import { saveErrorLog, saveSuccessLog } from 'services/api/utils'
 
 const cors = initMiddleware(Cors())
 
@@ -27,6 +28,7 @@ const defaultFrom = {
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   await cors(req, res)
   if (req.method === 'POST') {
+    const resultId = req.query.resultId as string | undefined
     const { credentialsId, recipients, body, subject, cc, bcc, replyTo } = (
       typeof req.body === 'string' ? JSON.parse(req.body) : req.body
     ) as SendEmailOptions
@@ -36,31 +38,44 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     if (!from)
       return res.status(404).send({ message: "Couldn't find credentials" })
 
-    const transporter = createTransport({
+    const transportConfig = {
       host,
       port,
       secure: isTlsEnabled ?? undefined,
       auth: {
         user: username,
         pass: password,
       },
-    })
-    const info = await transporter.sendMail({
+    }
+    const transporter = createTransport(transportConfig)
+    const email = {
       from: `"${from.name}" <${from.email}>`,
       cc,
       bcc,
       to: recipients,
       replyTo,
       subject,
       text: body,
-    })
-
-    res.status(200).send({
-      message: 'Email sent!',
-      info,
-      previewUrl: getTestMessageUrl(info),
-    })
+    }
+    try {
+      const info = await transporter.sendMail(email)
+      await saveSuccessLog(resultId, 'Email successfully sent')
+      return res.status(200).send({
+        message: 'Email sent!',
+        info,
+        previewUrl: getTestMessageUrl(info),
+      })
+    } catch (err) {
+      await saveErrorLog(resultId, 'Email not sent', {
+        transportConfig,
+        email,
+      })
+      return res.status(500).send({
+        message: `Email not sent. Error: ${err}`,
+      })
+    }
   }
+  return methodNotAllowed(res)
 }
 
 const getEmailInfo = async (

apps/viewer/pages/api/integrations/google-sheets/spreadsheets/[spreadsheetId]/sheets/[sheetId].ts

@@ -5,10 +5,12 @@ import { getAuthenticatedGoogleClient } from 'libs/google-sheets'
 import { Cell } from 'models'
 import Cors from 'cors'
 import { withSentry } from '@sentry/nextjs'
+import { saveErrorLog, saveSuccessLog } from 'services/api/utils'
 
 const cors = initMiddleware(Cors())
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   await cors(req, res)
+  const resultId = req.query.resultId as string | undefined
   if (req.method === 'GET') {
     const spreadsheetId = req.query.spreadsheetId.toString()
     const sheetId = req.query.sheetId.toString()
@@ -29,17 +31,27 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     doc.useOAuth2Client(client)
     await doc.loadInfo()
     const sheet = doc.sheetsById[sheetId]
-    const rows = await sheet.getRows()
-    const row = rows.find(
-      (row) => row[referenceCell.column as string] === referenceCell.value
-    )
-    if (!row) return res.status(404).send({ message: "Couldn't find row" })
-    return res.send({
-      ...extractingColumns.reduce(
-        (obj, column) => ({ ...obj, [column]: row[column] }),
-        {}
-      ),
-    })
+    try {
+      const rows = await sheet.getRows()
+      const row = rows.find(
+        (row) => row[referenceCell.column as string] === referenceCell.value
+      )
+      if (!row) {
+        await saveErrorLog(resultId, "Couldn't find reference cell")
+        return res.status(404).send({ message: "Couldn't find row" })
+      }
+      const response = {
+        ...extractingColumns.reduce(
+          (obj, column) => ({ ...obj, [column]: row[column] }),
+          {}
+        ),
+      }
+      await saveSuccessLog(resultId, 'Succesfully fetched spreadsheet data')
+      return res.send(response)
+    } catch (err) {
+      await saveErrorLog(resultId, "Couldn't fetch spreadsheet data", err)
+      return res.status(500).send(err)
+    }
   }
   if (req.method === 'POST') {
     const spreadsheetId = req.query.spreadsheetId.toString()
@@ -55,10 +67,16 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     if (!auth)
       return res.status(404).send("Couldn't find credentials in database")
     doc.useOAuth2Client(auth)
-    await doc.loadInfo()
-    const sheet = doc.sheetsById[sheetId]
-    await sheet.addRow(values)
-    return res.send({ message: 'Success' })
+    try {
+      await doc.loadInfo()
+      const sheet = doc.sheetsById[sheetId]
+      await sheet.addRow(values)
+      await saveSuccessLog(resultId, 'Succesfully inserted row')
+      return res.send({ message: 'Success' })
+    } catch (err) {
+      await saveErrorLog(resultId, "Couldn't fetch spreadsheet data", err)
+      return res.status(500).send(err)
+    }
   }
   if (req.method === 'PATCH') {
     const spreadsheetId = req.query.spreadsheetId.toString()
@@ -75,19 +93,25 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     if (!auth)
       return res.status(404).send("Couldn't find credentials in database")
     doc.useOAuth2Client(auth)
-    await doc.loadInfo()
-    const sheet = doc.sheetsById[sheetId]
-    const rows = await sheet.getRows()
-    const updatingRowIndex = rows.findIndex(
-      (row) => row[referenceCell.column as string] === referenceCell.value
-    )
-    if (updatingRowIndex === -1)
-      return res.status(404).send({ message: "Couldn't find row to update" })
-    for (const key in values) {
-      rows[updatingRowIndex][key] = values[key]
+    try {
+      await doc.loadInfo()
+      const sheet = doc.sheetsById[sheetId]
+      const rows = await sheet.getRows()
+      const updatingRowIndex = rows.findIndex(
+        (row) => row[referenceCell.column as string] === referenceCell.value
+      )
+      if (updatingRowIndex === -1)
+        return res.status(404).send({ message: "Couldn't find row to update" })
+      for (const key in values) {
+        rows[updatingRowIndex][key] = values[key]
+      }
+      await rows[updatingRowIndex].save()
+      await saveSuccessLog(resultId, 'Succesfully updated row')
+      return res.send({ message: 'Success' })
+    } catch (err) {
+      await saveErrorLog(resultId, "Couldn't fetch spreadsheet data", err)
+      return res.status(500).send(err)
     }
-    await rows[updatingRowIndex].save()
-    return res.send({ message: 'Success' })
   }
   return methodNotAllowed(res)
 }

apps/viewer/pages/api/typebots/[typebotId]/blocks/[blockId]/executeWebhook.ts

@@ -20,19 +20,22 @@ import {
   initMiddleware,
   methodNotAllowed,
   notFound,
+  omit,
   parseAnswers,
 } from 'utils'
 import { stringify } from 'qs'
 import { withSentry } from '@sentry/nextjs'
 import Cors from 'cors'
 import { parseSampleResult } from 'services/api/webhooks'
+import { saveErrorLog, saveSuccessLog } from 'services/api/utils'
 
 const cors = initMiddleware(Cors())
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   await cors(req, res)
   if (req.method === 'POST') {
     const typebotId = req.query.typebotId.toString()
     const stepId = req.query.blockId.toString()
+    const resultId = req.query.resultId as string | undefined
     const { resultValues, variables } = (
       typeof req.body === 'string' ? JSON.parse(req.body) : req.body
     ) as {
@@ -57,7 +60,8 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
       preparedWebhook,
       variables,
       step.blockId,
-      resultValues
+      resultValues,
+      resultId
     )
     return res.status(200).send(result)
   }
@@ -76,13 +80,14 @@ const prepareWebhookAttributes = (
   return webhook
 }
 
-const executeWebhook =
+export const executeWebhook =
   (typebot: Typebot) =>
   async (
     webhook: Webhook,
     variables: Variable[],
     blockId: string,
-    resultValues?: ResultValues
+    resultValues?: ResultValues,
+    resultId?: string
   ): Promise<WebhookResponse> => {
     if (!webhook.url || !webhook.method)
       return {
@@ -120,41 +125,55 @@ const executeWebhook =
             blockId,
           })
         : undefined
+    const request = {
+      url: parseVariables(variables)(
+        webhook.url + (queryParams !== '' ? `?${queryParams}` : '')
+      ),
+      method: webhook.method as Method,
+      headers,
+      ...basicAuth,
+      json:
+        contentType !== 'x-www-form-urlencoded' && body
+          ? JSON.parse(parseVariables(variables)(body))
+          : undefined,
+      form:
+        contentType === 'x-www-form-urlencoded' && body
+          ? JSON.parse(parseVariables(variables)(body))
+          : undefined,
+    }
     try {
-      const response = await got(
-        parseVariables(variables)(
-          webhook.url + (queryParams !== '' ? `?${queryParams}` : '')
-        ),
-        {
-          method: webhook.method as Method,
-          headers,
-          ...basicAuth,
-          json:
-            contentType !== 'x-www-form-urlencoded' && body
-              ? JSON.parse(parseVariables(variables)(body))
-              : undefined,
-          form:
-            contentType === 'x-www-form-urlencoded' && body
-              ? JSON.parse(parseVariables(variables)(body))
-              : undefined,
-        }
-      )
+      const response = await got(request.url, omit(request, 'url'))
+      await saveSuccessLog(resultId, 'Webhook successfuly executed.', {
+        statusCode: response.statusCode,
+        request,
+        response: parseBody(response.body),
+      })
       return {
         statusCode: response.statusCode,
         data: parseBody(response.body),
       }
     } catch (error) {
       if (error instanceof HTTPError) {
-        return {
+        const response = {
           statusCode: error.response.statusCode,
           data: parseBody(error.response.body as string),
         }
+        await saveErrorLog(resultId, 'Webhook returned an error', {
+          request,
+          response,
+        })
+        return response
       }
-      console.error(error)
-      return {
+      const response = {
         statusCode: 500,
         data: { message: `Error from Typebot server: ${error}` },
       }
+      console.error(error)
+      await saveErrorLog(resultId, 'Webhook failed to execute', {
+        request,
+        response,
+      })
+      return response
     }
   }