query-logging not work in nestjs with prisma service

[tastafur]

I have tried to use the extension in the service but it never logs information and I have tried to put it as your example and as the documentation but my loguer of the queries with the events on yes

const options = {
  log: [
    { emit: 'event', level: 'query' } as const,
    { emit: 'event', level: 'info' } as const,
    { emit: 'event', level: 'warn' } as const,
    { emit: 'event', level: 'error' } as const,
  ],
  errorFormat:
    process.env.NODE_ENV === 'production'
      ? ('minimal' as const)
      : ('pretty' as const),
};

@Injectable()
export class PrismaService
  extends PrismaClient<typeof options>
  implements OnModuleInit, OnModuleDestroy
{
  private readonly _logger = new Logger(PrismaService.name);

  public constructor() {
    super(options);
    this.$on('query', (e: Prisma.QueryEvent) => {
      console.log(e);
    });
    this.$on('info', (e: Prisma.LogEvent) => {
      this._logger.log(e.message);
    });
    this.$on('warn', (e: Prisma.LogEvent) => {
      this._logger.warn(e.message);
    });
    this.$on('error', (e: Prisma.LogEvent) => {
      this._logger.error(e.message);
    });

    this.$extends({
      query: {
        $allModels: {
          async $allOperations({ operation, model, args, query }) {
            const start = performance.now();
            const result = await query(args);
            const end = performance.now();
            const time = end - start;
            console.log(
              util.inspect(
                { model, operation, args, time },
                { showHidden: false, depth: null, colors: true },
              ),
            );
            return result;
          },
        },
      },
    });
  }
  async onModuleInit() {
    await this.$connect();
  }

  async onModuleDestroy() {
    await this.$disconnect();
  }

  async enableShutdownHooks(app: INestApplication) {
    process.on('beforeExit', async () => {
      await app.close();
    });
  }
}

[v3sker]

Did you eventually fixed it?
I also have this problem.

[yamalweb]

export DEBUG="prisma:client"

[v3sker]

export DEBUG="prisma:client"

???

[marcjulian]

Hi @tastafur,

the reason why the query-logging extension won't run is how $extends from PrismaClient works. $extends creates a new instance of the PrismaClient and only when you use the new instance to query your database you will see the logs or have access to other extensions.

Prisma docs describes this instance behavior with an example about applying multiple extensions. I also try to explain this below in the context of PrismaService for nest.

Two prisma instances with

@Injectable()
// `PrismaService extends PrismaClient` creates one instance of prisma client - calling the instance prisma
export class PrismaService extends PrismaClient {
  private logger = new Logger(PrismaService.name);

  constructor() {
    super();

    // `this.$extends` creates another instance - calling the instance prisma-logging
    const prismaLogging = this.$extends({
      query: {
        $allModels: {
          async $allOperations({ operation, model, args, query }) {
            const start = performance.now();
            const result = await query(args);
            const end = performance.now();
            const time = Math.ceil((end - start) * 100) / 100;
            // adjust logging behavior to your needs
            this.logger.log(
              `Prisma Query ${model}.${operation} took ${time}ms`,
            );
            return result;
          },
        },
      },
    });
  }
}

Here is an example, when you us PrismaService in a service. Any query/mutation against PrismaService only uses the first instance (prisma) which doesn't have any extension applied.

@Injectable()
export class AppService {
  constructor(
    // uses prisma client instance: prisma
    private prisma: PrismaService,
  ) {}

  users() {
    // query-logging is not executed with prisma instance
    return this.prisma.user.findMany();
  }
}

Solution to use the $extends instance

You would need to perform all your queries/mutations against the second instance (prisma-logging) to execute the query-logging extension. Here is an example how you could do that

@Injectable()
// `PrismaService` without `extends PrismaClient` - extends with a function call doesn't work
export class PrismaService {
  private logger = new Logger(PrismaService.name);

  // create an instance of prisma client with your extensions and allow public access
  // calling the instance prisma-logging
  public readonly client = new PrismaClient().$extends({
    query: {
      $allModels: {
        async $allOperations({ operation, model, args, query }) {
          const start = performance.now();
          const result = await query(args);
          const end = performance.now();
          const time = Math.ceil((end - start) * 100) / 100;
          // adjust logging behavior to your needs
          this.logger.log(`Prisma Query ${model}.${operation} took ${time}ms`);
          return result;
        },
      },
    },
  });
}

When you use this PrismaService you need to access the client to perform your queries/mutations - this.prisma.client.*

@Injectable()
export class AppService {
  constructor(
    // uses prisma client instance: prisma-logging
    private prisma: PrismaService,
  ) {}

  users() {
    // access to prisma functions with `this.prisma.client.*`
    // query-logging is executed because the instance prisma
    return this.prisma.client.user.findMany();
  }
}