Observability support

[kibertoad]

APM solutions, such as DataDog and New Relic can benefit from execution traces, such as OpenTelemetry, in order to provide useful runtime information about how queries are performing.

See how Prisma did it: https://github.com/prisma/prisma/tree/main/packages/instrumentation

It is worth mentioning that currently it is possible to instrument the driver library itself using instrumentation libraries provided by otel:

pg - https://www.npmjs.com/package/@opentelemetry/instrumentation-pg
mysql - https://www.npmjs.com/package/@opentelemetry/instrumentation-mysql

[gustavolzangelo]

It is worth mentioning that currently it is possible to instrument the driver library itself using instrumentation libraries provided by otel:

pg - https://www.npmjs.com/package/@opentelemetry/instrumentation-pg mysql - https://www.npmjs.com/package/@opentelemetry/instrumentation-mysql

@bohdan-sviripa Did you manage to make it work with Drizzle?

[issackr]

@gustavolzangelo I opened #1054 and tried it on my project.

I was able to work on drizzle with pg, and get the instrumentation working properly with instrumentation-pg

[jstlaurent]

There's already OpenTelemetry traces set up throughout the pg-core module. I've already setup Otel tracing in the rest of my app and it would be great to be able to turn it on for Drizzle as well.

[i-am-mani]

Does any similar library exists for OTEL Tracing for Planetscale? any suggestions on how one could include automatic tracing for queries?

[pudgereyem]

Also curious if there's any documentation on how you best go about setting up OpenTelemetry tracing when using Drizzle. I've done this with Prisma in the past and benefited from documentation such as the links below:

1. Docs - OpenTelemetry tracing
2. Monitor Your Server with Tracing Using OpenTelemetry & Prisma

Can you point us in the right direction here @AndriiSherman, @Angelelz? Thanks for a great ORM!

[Angelelz]

Drizzle doesn't have official support for this yet. At some point the team stated implementing something like that but it is not done yet.

[bearkfear]

for postgres you can use this packages to track traces

instrumentation libraries:

• postgresjs
• node-pg

probably will be like this:

instrumentations: [
                new PgInstrumentation({
                    enhancedDatabaseReporting: true,
                    enabled: true,
                    addSqlCommenterCommentToQueries: true,
                }),
            ],

[i-am-mani]

We use MySQL (Planetscale) and for us patching the db instance (or js Proxy) at the entry-point of package with manual tracing worked out. We only use it for dev/staging, no performance or other issues found so far.

Eg.

    Connection.prototype.execute = async function (query, values, options) {
      return trace.getTracer('database').startActiveSpan(query.toString(), async (span) => {
        span.setAttribute('db.statement', query);
        const _res = await originalMethod.call(this, query, values as any, options as any);
        span.end();
        return _res;
      });
    };

[AlexXanderGrib]

Suggestion:

• Add event emitter to drizzle() instance
• It emits whenever query begins, gets to driver and ends (or failes)
• Same with transactions
• Events can be instrumented like in @opentelemetry/instrumentation-undici (source)
• Event emitter is much lower overhead compared to @opentelemetry/api

OR even simpler:

Add this to src/drizzle-orm/tracing.ts

let otel: typeof import('@opentelemetry/api') | undefined;

export function setGlobalOtelApi(api: typeof import('@opentelemetry/api') | undefined): void {
  otel = api;
}

And this to index.ts

export { setGlobalOtelApi } from './tracing.ts';

OpenTelemetry itself uses global configuration, for example when starting Node SDK, so i believe usage of globals if appropriate here

[Jonatthu]

@AlexXanderGrib Could you do a pull request?

[AlexXanderGrib]

I tried vite rewrites and found out that drizzle tries to serialize query params to JSON for span attribues. But query params can be BigInt so it blows up

[Yhozen]

Hey!
based on @i-am-mani solution and @AlexXanderGrib concerns with BigInts I created the following workaround, (ab)using the logger.

class TracerLogger implements Logger {
  logQuery(query: string, params: unknown[]): void {
    const span = tracer.startSpan(query.toString())
    span.setAttribute('db.query', query)
    span.setAttribute('db.params', SuperJSON.stringify(params))

    return span.end()
  }
}


const db = drizzle(env.DATABASE_URL, { logger: new TracerLogger() })

Which works with the obvious problem that it is serialized with superjson (which supports BigInts and more) and no way to actually measure the execution time

But it is already possible to have telemetry with any drizzle driver

[taylor-wood-morpheus]

@Yhozen This is a step in the right direction. However, this Logger solution opens the span and then closes it again instantly.

I think the desired behavior would be:

1. The span opens at the start of the query, and then closes when the query completes.
2. Any other spans opened during the query will be nested in this span

---

That being said, the logger would be a good mechanism for enriching spans with span events.

A Span Event is a human-readable message on an Span that represents a discrete event with no duration that can be tracked by a single timestamp. You can think of it like a primitive log.

class TracerLogger implements Logger {
  logQuery(query: string, params: unknown[]): void {
    const span = trace.getActiveSpan();
    
    if(span) {
      span.addEvent('db.call', {query, params: SuperJSON.stringify(params)})
    }
  }
}