Analyser les tendances des appels d'API avec Prisma et Next.js : regroupement par semaine, mois ou année

Cet article de blog fournit une solution pratique pour regrouper les données par jour, mois ou année à l'aide de Prisma. J'ai moi-même eu du mal avec cela, c'est pourquoi je partage cette approche simplifiée. Nous utiliserons un point de terminaison d'API Next.js pour analyser les tendances des appels d'API à l'aide de Prisma et MongoDB, en nous concentrant sur les taux de réussite et la fréquence des appels au fil du temps.

Structure simplifiée des données d'appel d'API

Un tableau de bord efficace nécessite de regrouper les appels d'API par intervalles de temps. Utilisons un schéma Prisma concis :

<code>model ApiCall {
  id        String    @id @default(auto()) @map("_id") @db.ObjectId
  timestamp DateTime  @default(now())
  status    ApiCallStatus // Enum for success or failure.
}

enum ApiCallStatus {
  SUCCESS
  FAILURE
}</code>

Ce schéma suit l'horodatage et le statut de chaque appel d'API, suffisants pour l'analyse des tendances.

Interrogation des tendances des appels d'API : un point de terminaison d'API Next.js

Ce point de terminaison de l'API Next.js regroupe les données d'appel d'API, en les regroupant par périodes spécifiées (année, mois ou jour) :

<code>import { NextRequest, NextResponse } from 'next/server';
import { startOfYear, endOfYear, startOfMonth, endOfMonth } from 'date-fns';

export async function GET(req: NextRequest) {
    const range = req.nextUrl.searchParams.get("range"); // 'year' or 'month'
    const groupBy = req.nextUrl.searchParams.get("groupby"); // 'yearly', 'monthly', 'daily'

    // Input validation
    if (!range || (range !== 'year' && range !== 'month')) {
        return NextResponse.json({ error: "Range must be 'year' or 'month'" }, { status: 400 });
    }

    if (!groupBy || (groupBy !== 'yearly' && groupBy !== 'monthly' && groupBy !== 'daily')) {
        return NextResponse.json({ error: "Group by must be 'yearly', 'monthly', or 'daily'" }, { status: 400 });
    }

    try {
        let start: Date, end: Date;
        if (range === 'year') {
            start = startOfYear(new Date());
            end = endOfYear(new Date());
        } else { // range === 'month'
            start = startOfMonth(new Date());
            end = endOfMonth(new Date());
        }

        let groupByFormat: string;
        switch (groupBy) {
            case 'yearly':
                groupByFormat = "%Y";
                break;
            case 'monthly':
                groupByFormat = "%Y-%m";
                break;
            case 'daily':
                groupByFormat = "%Y-%m-%d";
                break;
        }

        const apiCallTrends = await db.apiCall.aggregateRaw({
            pipeline: [
                {
                    $match: {
                        timestamp: { $gte: { $date: start }, $lte: { $date: end } }
                    }
                },
                {
                    $group: {
                        _id: { $dateToString: { format: groupByFormat, date: '$timestamp' } },
                        SUCCESS: { $sum: { $cond: [{ $eq: ['$status', 'SUCCESS'] }, 1, 0] } },
                        FAILURE: { $sum: { $cond: [{ $eq: ['$status', 'FAILURE'] }, 1, 0] } },
                        TOTAL: { $sum: 1 }
                    }
                },
                {
                    $sort: {
                        _id: 1
                    }
                }
            ]
        });

        return NextResponse.json({ apiCallTrends });
    } catch (error) {
        console.error(error);
        return NextResponse.json({ error: "An error occurred while fetching data." }, { status: 500 });
    }
}</code>

Exemple de réponse

Une demande comme celle-ci :

<code>GET /api/your-endpoint?range=year&groupby=monthly</code>

Pourrait donner cette réponse :

<code>{
  "apiCallTrends": [
    {
      "_id": "2025-01", // January 2025
      "SUCCESS": 120,
      "FAILURE": 15,
      "TOTAL": 135
    },
    {
      "_id": "2025-02", // February 2025
      "SUCCESS": 110,
      "FAILURE": 10,
      "TOTAL": 120
    },
    {
      "_id": "2025-03", // March 2025
      "SUCCESS": 130,
      "FAILURE": 20,
      "TOTAL": 150
    }
    // ... more monthly data
  ]
}</code>

Fonctionnalités clés

• Regroupement horaire flexible : Regroupez facilement par année, mois ou jour.
• Analyse complète des tendances : Fournit le nombre de réussites/échecs et les totaux pour chaque période.
• Gestion robuste des erreurs : Comprend des réponses d'erreur claires.
• Performances optimisées : Tire parti du pipeline d'agrégation de MongoDB pour plus d'efficacité.

Conclusion

Cette approche fournit une méthode robuste et efficace pour interroger et analyser des données horodatées regroupées par différentes plages de temps au sein de MongoDB, à l'aide de l'ORM Prisma. Merci d'avoir lu! Merci d'aimer et de vous abonner pour plus de contenu ! Connectez-vous avec moi sur GitHub et LinkedIn.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!