Full, native support for Firebase Functions

[Nathan1258]

Problem Statement

It would be great to have official support for Firebase Functions in general.

Solution Brainstorm

Some of my application still runs on Firebase functions and cannot be easily migrated as they rely on Firestore triggers. It would be great to have official support for Firebase Functions in general. I have create my own wrappers but they may not be correct, and cannot benefit from features such as Agent Insights when the function calls (for example) an OpenAI SDK function.

Additional Context

_{Tip: React with 👍 to help prioritize this improvement. Please use comments to provide useful context, avoiding +1 or me too, to help us triage it.}

[linear]

JS-1021

[JPeer264]

hey @Nathan1258 thanks for your feature request. It is great that you already made your own wrapper. Would you mind sharing this snippet?

For now it makes sense to add a simple documentation on how to instrument Firebase functions manually with Sentry. I'll take care of that.

[Nathan1258]

Hi @JPeer264, thanks for your reply. See below where I've attached four wrappers (onRequest, onCall, Firestore Trigger, and background triggers). Again, entirely unsure if this is the correct way of going about this, but it makes my code a lot cleaner for capturing errors. I haven't been able to log any AI insights with this.

module.exports.httpsOnRequestWrapper = (name, handler) => {
    return async (req, res) => {
        return Sentry.startSpan(
            {
                name,
                op: "onRequest",
            },
            async (span) => {
                Sentry.setContext("Request context", {
                    path: req.path,
                    query: req.query,
                    method: req.method,
                    function: name,
                    op: "onRequest",
                });

                try {
                    const result = await handler(req, res);
                    if (span) span.setStatus("ok");
                    return result;
                } catch (error) {
                    Sentry.captureException(error);
                    await Sentry.flush(2000);
                    if (!res.headersSent) {
                        res.status(500).send("An internal error occurred.");
                    }
                } finally {
                    Sentry.getCurrentScope().clear();
                }
            }
        );
    };
};
module.exports.httpsOnCallWrapper = (name, handler, options = {}) => {
    const { requiresAuth = true } = options;

    return async (event) => {
        if (requiresAuth && !event.auth) {
            console.warn(`Unauthenticated call to function: ${name}`);
            Sentry.captureMessage(`Unauthenticated call attempt to ${name}`, 'warning');
            throw new HttpsError(
                'unauthenticated',
                'The function must be called while authenticated.'
            );
        }
        return Sentry.startSpan(
            {
                name,
                op: "onCall",
            },
            async (span) => {
                Sentry.setContext("Function context", {
                    uid: event.auth?.uid || "unauthenticated",
                    token: event.auth?.token?.email || (requiresAuth ? 'No email in token' : 'Auth not required'),
                    dataKeys: event.data ? Object.keys(event.data) : 'no data',
                    function: name,
                    op: "onCall",
                    requiresAuth: requiresAuth
                });

                try {
                    const result = await handler(event);
                    if (span) span.setStatus("ok");
                    return result;
                } catch (error) {
                    Sentry.captureException(error);
                    await Sentry.flush(2000);
                    if (error instanceof V1HttpsError) {
                        throw error;
                    } else {
                        throw new V1HttpsError('internal', error.message || `An internal error occurred in ${name}.`, { detail: error.toString() });
                    }
                } finally {
                    Sentry.getCurrentScope().clear()
                }
            }
        );
    };
};
module.exports.firestoreWrapper = (name, handler, triggerType = "firestore.trigger") => {
    return async (event) => {
        return Sentry.startSpan(
            { name, op: triggerType },
            async (span) => {
                Sentry.setContext("Function context", {
                    ...(event || {}),
                    uid: event.auth?.uid || "unauthenticated",
                    function: name,
                    op: "firestoreTrigger",
                });
                try {
                    const result = await handler(event);
                    if (span) span.setStatus("ok");
                    return result;
                } catch (error) {
                    console.error(`Error in firestore function ${name} (${triggerType}):`, error);
                    Sentry.captureException(error, {
                        extra: { functionName: name, triggerType: triggerType }
                    });
                    if (span) span.setStatus("internal_error");
                    await Sentry.flush(2000);

                    if (error instanceof V1HttpsError) {
                        throw error;
                    } else {
                        throw new V1HttpsError('internal', error.message || `An internal error occurred in ${triggerType}.`, { detail: error.toString() });
                    }
                } finally {
                    Sentry.getCurrentScope().clear();
                }
            }
        );
    };
};
module.exports.backgroundTriggerWrapper = (name, handler, triggerType = "background.trigger") => {
    return async (data, context) => {
        const eventContext = context || data;

        return Sentry.startSpan(
            {
                name,
                op: triggerType
            },
            async (span) => {
                Sentry.setContext("Function Details", {
                    functionName: name,
                    triggerType: triggerType,
                    eventId: eventContext.eventId,
                    eventType: eventContext.eventType,
                    timestamp: eventContext.timestamp,
                    resource: eventContext.resource ? (typeof eventContext.resource === 'string' ? eventContext.resource : JSON.stringify(eventContext.resource)) : undefined,
                    userId: data && data.uid,
                    userEmail: data && data.email,
                });

                try {
                    const result = await handler(data, eventContext);
                    if (span) span.setStatus("ok");
                    return result;
                } catch (error) {
                    console.error(`Error in background function ${name} (${triggerType}):`, error);
                    Sentry.captureException(error, {
                        extra: { functionName: name, triggerType: triggerType, eventId: eventContext.eventId }
                    });
                    if (span) span.setStatus("internal_error");
                    await Sentry.flush(2000);

                    if (error instanceof V1HttpsError) {
                        throw error;
                    } else {
                        throw new V1HttpsError('internal', error.message || `An internal error occurred in ${triggerType}.`, { detail: error.toString() });
                    }
                } finally {
                    Sentry.getCurrentScope().clear();
                }
            }
        );
    };
};

[JPeer264]

thx for the insights. That's already some nice work you've done 👍 I'll keep you posted when there are some updates from my side