Analysieren von API-Aufruftrends mit Prisma und Next.js: Gruppierung nach Woche, Monat oder Jahr

Dieser Blogbeitrag bietet eine praktische Lösung zum Gruppieren von Daten nach Tag, Monat oder Jahr mithilfe von Prisma. Ich hatte selbst damit zu kämpfen, deshalb teile ich diesen optimierten Ansatz. Wir verwenden einen Next.js-API-Endpunkt, um API-Aufruftrends mit Prisma und MongoDB zu analysieren, wobei wir uns auf Erfolgsraten und Aufrufhäufigkeit im Zeitverlauf konzentrieren.

Vereinfachte API-Aufrufdatenstruktur

Effektives Dashboarding erfordert die Gruppierung von API-Aufrufen nach Zeitintervallen. Lassen Sie uns ein prägnantes Prisma-Schema verwenden:

<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>

Dieses Schema verfolgt den Zeitstempel und den Status jedes API-Aufrufs, was für eine Trendanalyse ausreichend ist.

API-Aufruftrends abfragen: Ein Next.js-API-Endpunkt

Dieser Next.js-API-Endpunkt aggregiert API-Aufrufdaten und gruppiert sie nach bestimmten Zeiträumen (Jahr, Monat oder Tag):

<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>

Beispielantwort

Eine Anfrage wie diese:

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

Könnte zu dieser Antwort führen:

<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>

Hauptfunktionen

• Flexible Zeitgruppierung: Einfache Gruppierung nach Jahr, Monat oder Tag.
• Umfassende Trendanalyse: Bietet Erfolgs-/Misserfolgszahlen und Gesamtzahlen für jeden Zeitraum.
• Robuste Fehlerbehandlung:Beinhaltet klare Fehlerreaktionen.
• Optimierte Leistung:Nutzt die Aggregationspipeline von MongoDB für Effizienz.

Fazit

Dieser Ansatz bietet eine robuste und effiziente Methode zum Abfragen und Analysieren zeitgestempelter Daten, die nach verschiedenen Zeitbereichen in MongoDB gruppiert sind, mithilfe des Prisma ORM. Danke fürs Lesen! Bitte liken und abonnieren Sie für weitere Inhalte! Vernetzen Sie sich mit mir auf GitHub und LinkedIn.

Das obige ist der detaillierte Inhalt vonAnalysieren von API-Aufruftrends mit Prisma und Next.js: Gruppierung nach Woche, Monat oder Jahr. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!