Belajar GraphQL - Production Monitoring & Observability

#Pendahuluan

API yang tidak bisa diamati sama dengan berjalan dalam kegelapan. Episode 24 membangun observability untuk GraphQL production: logging, tracing, metrik, dan health checks yang membuat kalian bisa melihat apa yang terjadi di dalam server dari luar. Kita akan membahas logging terstruktur dengan Pino, query analytics dengan Apollo Studio, distributed tracing dengan OpenTelemetry, metrik dengan Prometheus dan Grafana, APM untuk error tracking, serta health checks.

#Logging Strategies

#Structured Logging dengan Pino

Log di production harus terstruktur — JSON dengan field konsisten — agar bisa difilter dan di-agregasi. Pino adalah pilihan populer karena cepat; install dengan npm install pino:

Logger terstruktur

import pino from "pino";
 
export const logger = pino({
  level: process.env.LOG_LEVEL ?? "info",
});

#Logging Query dan Resolver

Integrasikan logger ke context agar setiap resolver memakai logger yang sama — buat logger turunan per request dengan logger.child({ requestId: crypto.randomUUID() }):

Logger di context

const { url } = await startStandaloneServer(server, {
  context: async ({ req }) => ({
    logger: logger.child({ requestId: crypto.randomUUID() }),
    user,
  }),
});

Plugin log durasi resolver

import { ApolloServerPlugin } from "@apollo/server";
 
const logPlugin = {
  async requestDidStart() {
    return {
      async willSendResponse({ response, contextValue }) {
        contextValue.logger.info({ body: response.body }, "response dikirim");
      },
    };
  },
};

#Apollo Studio

#Query Analytics dan Error Tracking

Apollo Studio adalah platform observability Apollo yang menampilkan operasi GraphQL secara langsung. Setelah mendaftarkan graph dan mengisi key:

Hubungkan ke Apollo Studio

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [ApolloServerPluginUsageReporting({ sendErrors: { unmodified: true } })],
});

#OpenTelemetry Integration

#Distributed Tracing

Dalam arsitektur microservices, sebuah query melewati banyak service. OpenTelemetry menstandardisasi tracing agar perjalanan satu request bisa dilacak lintas service; install dengan npm install @opentelemetry/api @opentelemetry/sdk-node @opentelemetry/auto-instrumentations-node:

Inisialisasi OpenTelemetry

import { NodeSDK } from "@opentelemetry/sdk-node";
import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 
const sdk = new NodeSDK({
  traceExporter: { url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT },
  instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();

Konsep intinya: setiap request membawa trace id, dipecah menjadi span (satu per resolver atau per query database), dan context melewati propagation agar service penerima tetap dalam trace yang sama. Ini membuat bottleneck antar-service terlihat jelas.

#Metrics dan APM

#Prometheus dan Grafana

Untuk metrik, ekspos metrik Prometheus dari server; install dengan npm install prom-client:

Metrik kustom

import { Counter, Histogram } from "prom-client";
 
const queriesTotal = new Counter({
  name: "graphql_queries_total",
  help: "Jumlah query",
  labelNames: ["operationName"],
});
 
const queryDuration = new Histogram({
  name: "graphql_query_duration_seconds",
  help: "Durasi query",
  labelNames: ["operationName"],
});

Prometheus menarik metrik dari endpoint /metrics, dan Grafana menampilkannya sebagai dashboard. Metrik yang wajib ada: total query per operasi, histogram durasi, jumlah error, dan kesehatan database.

#APM dan Sentry

Untuk error tracking, integrasikan Sentry; install dengan npm install @sentry/node:

Sentry untuk error tracking

import * as Sentry from "@sentry/node";
 
Sentry.init({ dsn: process.env.SENTRY_DSN });
 
const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    {
      async requestDidStart() {
        return {
      async didEncounterErrors({ errors }) {
        errors.forEach(Sentry.captureException);
      },
        };
      },
    },
  ],
});

Sentry menampilkan error beserta stack trace, user, dan konteks request — menggantikan kebiasaan "melihat log di server". Alternatif lain: Datadog dan New Relic untuk APM terintegrasi.

#Health Checks

#Readiness dan Liveness

Health checks memberi tahu orchestrator (Kubernetes, load balancer) apakah aplikasi sehat:

• Liveness: "apakah proses masih hidup?" — jika gagal, proses di-restart.
• Readiness: "apakah siap menerima traffic?" — jika gagal, traffic dialihkan.

Health check endpoint

app.get("/health/live", (req, res) => {
  res.json({ status: "ok" });
});
 
app.get("/health/ready", async (req, res) => {
  try {
    await prisma.$queryRaw`SELECT 1`;
    res.json({ status: "ok" });
  } catch {
    res.status(503).json({ status: "degraded" });
  }
});

Readiness check menguji dependency (database, Redis) sehingga load balancer tahu kapan aplikasi sebenarnya siap. Ini wajib dipasang sebelum deployment otomatis — kita pakai lagi di episode 31 dan 35.

#Penutup

Inti yang harus dibawa pulang:

• Logging terstruktur dengan Pino dan requestId memudahkan pelacakan.
• Apollo Studio memberi query analytics dan schema checks otomatis.
• OpenTelemetry menstandardisasi distributed tracing lintas service.
• Prometheus dan Grafana menampilkan metrik query, error, dan durasi.
• Sentry menangkap error production beserta konteks lengkapnya.
• Health checks liveness dan readiness menjadi dasar deployment sehat.

Di episode 25 selanjutnya kalian akan mempelajari Apollo Client fundamentals — setup client dan ApolloProvider, hook useQuery dengan polling dan refetch, useMutation dengan optimistic UI, manajemen cache InMemoryCache, hingga local state dengan reactive variables. Sisi frontend akan tersambung penuh ke GraphQL!