File size: 4,167 Bytes
2477a46
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
from datetime import datetime

from psycopg2.extras import Json

from src.api.monitoring.db import get_connection


def log_api_request(
    endpoint,
    status_code,
    success,
    latency_ms,
    model_name,
    model_version,
    input_data,
    output_data=None,
    error_message=None,
):
    """génère une entrée dans la table api_requests et retourne l'id de la requête
    Args:
        endpoint (str): Le point de terminaison de l'API appelé (ex: "predict", "recommend").
        status_code (int): Le code de statut HTTP de la réponse (ex: 200, 400).
        success (bool): Indique si la requête a été traitée avec succès.    
        latency_ms (float): Le temps de latence total de la requête en millisecondes.
        model_name (str): Le nom du modèle utilisé pour la prédiction.
        model_version (str): La version du modèle utilisé pour la prédiction.
        input_data (dict): Les données d'entrée envoyées à l'API.
        output_data (dict, optional): Les données de sortie retournées par l'API.
        error_message (str, optional): Un message d'erreur si la requête a échoué.
    Returns:
        int: L'id de la requête nouvellement créée dans la table api_requests.
    """
    query = """
    INSERT INTO api_requests (
        timestamp, endpoint, status_code, success, error_message,
        latency_ms, model_name, model_version, input_json, output_json
    )
    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
    RETURNING id;
    """

    with get_connection() as conn:
        with conn.cursor() as cursor:
            cursor.execute(
                query,
                (
                    datetime.now(),
                    endpoint,
                    status_code,
                    success,
                    error_message,
                    latency_ms,
                    model_name,
                    str(model_version),
                    Json(input_data),
                    Json(output_data),
                ),
            )
            request_id = cursor.fetchone()[0]

    return request_id


def log_inference_step(
    request_id,
    step_name,
    success,
    duration_ms,
    details=None,
    error_message=None,
):
    query = """
    INSERT INTO inference_steps (
        request_id, step_name, success, error_message, duration_ms, details_json
    )
    VALUES (%s, %s, %s, %s, %s, %s);
    """

    with get_connection() as conn:
        with conn.cursor() as cursor:
            cursor.execute(
                query,
                (
                    request_id,
                    step_name,
                    success,
                    error_message,
                    duration_ms,
                    Json(details),
                ),
            )


def log_api_prediction(
    request_id,
    area,
    prediction_type,
    item=None,
    recommended_crop=None,
    predicted_yield=None,
    n_candidates=None,
):
    query = """
    INSERT INTO api_predictions (
        request_id, area, item, recommended_crop,
        predicted_yield, n_candidates, prediction_type
    )
    VALUES (%s, %s, %s, %s, %s, %s, %s);
    """

    with get_connection() as conn:
        with conn.cursor() as cursor:
            cursor.execute(
                query,
                (
                    request_id,
                    area,
                    item,
                    recommended_crop,
                    predicted_yield,
                    n_candidates,
                    prediction_type,
                ),
            )


def log_recommendation_details(request_id, ranking):
    query = """
    INSERT INTO api_recommendation_details (
        request_id, rank, item, predicted_yield
    )
    VALUES (%s, %s, %s, %s);
    """

    with get_connection() as conn:
        with conn.cursor() as cursor:
            for row in ranking:
                cursor.execute(
                    query,
                    (
                        request_id,
                        int(row["rank"]),
                        row["item"],
                        float(row["predicted_yield"]),
                    ),
                )