Supabase apps
Watch an app built on Supabase, from the browser's calls to your database through to Edge Functions, with database calls as spans and people identified from Supabase Auth.
This guide is for an app whose backend is Supabase: the browser talks to Supabase directly, and maybe to a few Edge Functions. It works with Sypnia Cloud and with a self-hosted engine; add endpoint to each init for your own engine.
At the end you will have: every call from the page to your Supabase project recorded with its table and its status, failed calls (a row-level security rule that says no, a missing column) turned into problems, people identified from Supabase Auth, and your Edge Functions traced with their own database calls.
You need: the browser SDK installed, and your Supabase project’s URL, such as https://abcdefghijkl.supabase.co.
In the browser
By default the SDK records calls to your own origin only. Your Supabase project is another origin, so name it.
import { init } from '@sypnia/browser';
const SUPABASE_URL = 'https://abcdefghijkl.supabase.co';
init({
project: 'spk_7d1f0c9e4b8a2f6d3c5e1a9b0f4d8c2e',
environment: location.hostname === 'shop.example' ? 'production' : 'development',
recordTargets: [SUPABASE_URL],
traceTargets: [`${SUPABASE_URL}/functions/v1/`],
});| Option | Covers | Adds headers? |
|---|---|---|
recordTargets | Everything supabase-js calls: the database (/rest/v1/…), Auth (/auth/v1/…), Storage (/storage/v1/…). | No. Supabase’s own services would refuse headers they do not know, and your calls would fail. |
traceTargets | Your Edge Functions (/functions/v1/…). | Yes: traceparent and x-sypnia-session, so the function joins the trace. You allow them in the function, below. |
You change nothing in how you create or use the Supabase client.
What a database call looks like in Sypnia
supabase.from('orders').insert(order) refused by a row-level security rule becomes this event:
{
"type": "request",
"method": "POST",
"host": "abcdefghijkl.supabase.co",
"path": "/rest/v1/orders",
"status": 403,
"dur": 87,
"code": "42501",
"msg": "new row violates row-level security policy for table \"orders\""
}- The table is in the path, so Performance lists
POST /rest/v1/orderswith its speed and its failures, and a problem can say which table refused. - The filter is never sent. Supabase puts filters in the query string (
?email=eq.ada@example.com), and the SDK never records a query string. - Only the code and the message are read from a failed answer. The
detailsandhintfields, which can repeat the row that failed, are never read. Row data and request bodies are never sent. - Realtime connections are not recorded: they are not requests.
Which answers count as failures: no answer, 400, and 500 or above. A 401 or a 404 is an answer. An insert that row-level security refuses is recorded with its 403, its code and its message, and is counted in Performance among that route’s 4xx answers; it becomes a problem when your code throws because of it, which most code does.
Identify people from Supabase Auth
import { identify } from '@sypnia/browser';
import { supabase } from './supabase';
supabase.auth.onAuthStateChange((_event, session) => {
if (session) identify({ person: { id: session.user.id } });
else identify(null);
});The id is Supabase’s user id, a UUID. Add email: session.user.email only if you want e-mail addresses in Sypnia; see Identifying people. onAuthStateChange also fires when the page loads with a signed-in user, so this one place is enough.
In Edge Functions
Edge Functions are functions from a Request to a Response, which is what wrapFetchHandler of the Node SDK traces. Import it with the npm: prefix.
import { createClient } from 'npm:@supabase/supabase-js@2';
import { init, wrapFetchHandler } from 'npm:@sypnia/node';
init({
project: Deno.env.get('SYPNIA_PROJECT_KEY'),
service: 'checkout-function',
environment: Deno.env.get('SYPNIA_ENVIRONMENT') ?? 'production',
});
const cors = {
'Access-Control-Allow-Origin': 'https://shop.example',
'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type, traceparent, x-sypnia-session',
};
Deno.serve(wrapFetchHandler(async (request: Request) => {
if (request.method === 'OPTIONS') return new Response('ok', { headers: cors });
const supabase = createClient(Deno.env.get('SUPABASE_URL')!, Deno.env.get('SUPABASE_ANON_KEY')!, {
global: { headers: { Authorization: request.headers.get('Authorization')! } },
});
const { data: cart, error } = await supabase.from('carts').select('id, total_cents').single();
if (error) throw error;
const payment = await fetch('https://payments.example/v1/payments', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ amount: cart.total_cents }),
});
return Response.json({ ok: payment.ok }, { status: payment.ok ? 200 : 502, headers: cors });
}));supabase secrets set SYPNIA_PROJECT_KEY=spk_7d1f0c9e4b8a2f6d3c5e1a9b0f4d8c2e
supabase functions deploy checkoutTwo lines are the whole integration: init, and wrapFetchHandler around your handler. The third thing to get right is the CORS header: add traceparent and x-sypnia-session to Access-Control-Allow-Headers. Without them the browser refuses to call the function once it is listed in traceTargets.
What you get for one call to this function:
click «Pay $64.00» browser
└─ POST /functions/v1/checkout 412 ms 502 checkout-function
├─ SELECT carts 18 ms ok database
└─ POST /v1/payments 340 ms 400 payments.example <- failed- Database calls are spans. The SDK recognizes Supabase’s database address and names the span by operation and table:
SELECT carts,INSERT orders,UPDATE carts,DELETE cart_items,CALL create_orderfor a database function called withrpc(). - Other calls are spans too, named by method and path.
- Errors thrown by the handler are reported with their stack, and the request is marked failed.
- The person comes from the browser session that made the call. You do not identify again.
Sending happens after the response, using the platform’s way to keep a function alive for background work when it offers one, and otherwise waiting at most 50 ms. How Supabase runs background work in Edge Functions is its own feature: check Supabase’s current documentation if you see events missing from short functions, and call await flush() before returning as a fallback.
What this does not cover
| Not covered | Why | Today’s answer |
|---|---|---|
| What happens inside Postgres: triggers, database functions, slow queries by plan | Sypnia sees calls to the database, not the database’s inside. | Supabase’s own database reports. |
| Database webhooks and scheduled functions that no browser called | They run, and are traced if they are Edge Functions with the wrapper, as traces of their own without a session. | — |
| Calls made by Supabase’s services to each other | They are not your app’s calls. | — |
| A native mobile app using Supabase | Native SDKs are Planned. | A web-view app works with the browser SDK. |