import { trace, context } from "@opentelemetry/api";
import { PrismaClient } from ".prisma/client";
import { otelSetup } from "./otelSetup";

otelSetup();

// set things up for tracing our "app"
const tracer = trace.getTracer("myApp");
const span = tracer.startSpan("mySpan");
const ctx = trace.setSpan(context.active(), span);

context.with(ctx, async () => {
  await main();

  span.end();
});

async function main() {
  const prisma = new PrismaClient();

  // this middleware gets the current span and add info to it
  prisma.$use(function spanModifierMiddleware(params, next) {
    const span = trace.getSpan(context.active())

    span.setAttributes({
      model: params['model'],
      action: params['action']
    });

    return next(params)
  });

  // this middleware self-registers in a span to trace itself
  prisma.$use(function spanCreatingMiddleware(params, next) {
    const span = tracer.startSpan("middleware");
    const ctx = trace.setSpan(context.active(), span)

    const result = context.with(ctx, () => next(params));

    span.end()

    return result
  });

  // here begins the actual prisma client logic to be traced
  const email = Date.now() + "@gmail.com"

  await prisma.user.create({
    data: {
      name: 'John Doe',
      email: email,
      link: {
        create: {
          url: "http://www.google.com",
          shortUrl: "http://www.google.com",
        },
      },
    },
  });

  await prisma.user.findMany({})

  await prisma.$transaction([
    prisma.user.findUnique({
      where: { email }
    }),
    prisma.user.findMany({})
  ])

  await prisma.$disconnect();
}

import { Resource } from "@opentelemetry/resources";
import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
import {
  BasicTracerProvider,
  ConsoleSpanExporter,
  SimpleSpanProcessor,
} from "@opentelemetry/sdk-trace-base";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { AsyncHooksContextManager } from "@opentelemetry/context-async-hooks";
import * as api from "@opentelemetry/api";

/** SETUP */

export function otelSetup() {
  // a context manager is required to propagate the context
  const contextManager = new AsyncHooksContextManager().enable();

  // it's for node.js for span nesting and ctx propagation
  api.context.setGlobalContextManager(contextManager);

  // a simple exporter that logs the raw data to the console
  const consoleExporter = new ConsoleSpanExporter();

  // exporter that natively works with jaeger without extras
  const otlpTraceExporter = new OTLPTraceExporter();
  // docker run --rm -d -p 13133:13133 -p 16686:16686 -p 4317:55680 jaegertracing/opentelemetry-all-in-one:latest

  // a standard provider that can run on the web and in node
  const provider = new BasicTracerProvider({
    resource: new Resource({
      // we can define some metadata about the trace resource
      [SemanticResourceAttributes.SERVICE_NAME]: "basic-service",
      [SemanticResourceAttributes.SERVICE_VERSION]: "1.0.0",
    }),
  });

  // a provider combines multiple exporters to send the data
  // provider.addSpanProcessor(new SimpleSpanProcessor(consoleExporter));
  provider.addSpanProcessor(new SimpleSpanProcessor(otlpTraceExporter));

  // makes the provider the global tracer provider for telemetry
  provider.register();
}