Monitoring de l

Catégorie

DevOps

Publié

14. Feb. 2026

Auteur

Le monitoring de l’ABAP Environment est essentiel pour le fonctionnement stable de vos applications ABAP Cloud sur SAP BTP. Contrairement à l’On-Premise, BTP met à disposition des outils de monitoring cloud-native spécialisés qui surveillent la santé, les performances et les jobs.

Outils de monitoring disponibles

SAP BTP ABAP Environment offre différents niveaux de surveillance :

Outil	Objectif	Audience cible
SAP BTP Cockpit	Monitoring infrastructure	Administrateur Cloud
App Fiori: Health Monitoring	Santé du système	Administrateur ABAP
App Fiori: SQL Trace Analysis	Diagnostic performance	Développeur/Admin
App Fiori: ABAP Runtime Errors	Analyse des erreurs	Développeur
App Fiori: Manage Background Tasks	Surveillance des jobs	Administrateur
Application Jobs	Planification et statut des jobs	Administrateur
Application Logs	Analyse des protocoles	Développeur/Admin
SAP Cloud ALM	Monitoring entreprise	IT Operations

Apercu de l’architecture

┌─────────────────────────────────────────────────────────────────────────────┐
│                    SAP BTP ABAP Environment Monitoring                       │
│                                                                              │
│  ┌────────────────────────────────────────────────────────────────────────┐ │
│  │                        SAP BTP Cockpit                                  │ │
│  │  - Service Health                                                       │ │
│  │  - Resource Usage (Memory, CPU)                                        │ │
│  │  - Connectivity Status                                                  │ │
│  └────────────────────────────────────────────────────────────────────────┘ │
│                                    │                                         │
│                                    ▼                                         │
│  ┌────────────────────────────────────────────────────────────────────────┐ │
│  │                    ABAP Environment Instance                            │ │
│  │                                                                         │ │
│  │  ┌─────────────────────┐  ┌─────────────────────┐                     │ │
│  │  │   Health Monitoring │  │  SQL Trace Analysis │                     │ │
│  │  │   (System Health)   │  │  (Performance)      │                     │ │
│  │  └─────────────────────┘  └─────────────────────┘                     │ │
│  │                                                                         │ │
│  │  ┌─────────────────────┐  ┌─────────────────────┐                     │ │
│  │  │  Application Jobs   │  │  Application Logs   │                     │ │
│  │  │  (Background Tasks) │  │  (Protocoles)       │                     │ │
│  │  └─────────────────────┘  └─────────────────────┘                     │ │
│  │                                                                         │ │
│  │  ┌─────────────────────┐  ┌─────────────────────┐                     │ │
│  │  │  ABAP Runtime Errors│  │  Communication      │                     │ │
│  │  │  (ST22 Cloud)       │  │  Arrangements       │                     │ │
│  │  └─────────────────────┘  └─────────────────────┘                     │ │
│  └────────────────────────────────────────────────────────────────────────┘ │
│                                    │                                         │
│                                    ▼                                         │
│  ┌────────────────────────────────────────────────────────────────────────┐ │
│  │                       SAP Cloud ALM (optionnel)                         │ │
│  │  - Cross-System Monitoring                                              │ │
│  │  - Alerting & Notifications                                             │ │
│  │  - Operations Dashboard                                                 │ │
│  └────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘

Health Monitoring et alertes

App Fiori : Health Monitoring

L’app “Health Monitoring” (App-ID: F5687) affiche l’état de santé actuel du système ABAP :

┌────────────────────────────────────────────────────────────────────────────┐
│  Health Monitoring                                                          │
│                                                                             │
│  System Status: ● Healthy                     Last Check: 14.02.2026 10:23 │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐  │
│  │  Key Metrics                                                          │  │
│  │                                                                        │  │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  │  │
│  │  │   Memory    │  │    CPU      │  │  DB Conns   │  │   Sessions  │  │  │
│  │  │    72%      │  │    45%      │  │   23/100    │  │    15/50    │  │  │
│  │  │   ████████░░│  │   █████░░░░░│  │   ███░░░░░░░│  │   ██░░░░░░░░│  │  │
│  │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘  │  │
│  └──────────────────────────────────────────────────────────────────────┘  │
│                                                                             │
│  Recent Events:                                                             │
│  ⚠ 10:15 - High memory usage detected (85%)                                │
│  ✓ 09:45 - Scheduled maintenance completed                                  │
│  ✓ 09:00 - Daily health check passed                                        │
└────────────────────────────────────────────────────────────────────────────┘

Métriques de santé importantes

Métrique	Description	Seuil critique
Memory Usage	Utilisation mémoire du système ABAP	> 90%
CPU Usage	Utilisation processeur	> 85% soutenu
DB Connections	Connexions base de données actives	> 80% de la limite
Work Processes	WPs Dialog/Background disponibles	< 20% libres
Response Time	Temps de réponse moyen	> 2 secondes
Active Sessions	Utilisateurs connectés	> 80% de la limite

Alertes avec SAP Cloud ALM

" Monitoring d'alertes programmatique via API
CLASS zcl_health_monitor DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    TYPES:
      BEGIN OF ty_health_status,
        component       TYPE string,
        status          TYPE string,
        message         TYPE string,
        timestamp       TYPE timestamp,
        memory_percent  TYPE i,
        cpu_percent     TYPE i,
      END OF ty_health_status.

    METHODS:
      get_current_health
        RETURNING VALUE(rs_status) TYPE ty_health_status.

    METHODS:
      check_and_alert
        RAISING cx_failed.

  PRIVATE SECTION.
    CONSTANTS:
      gc_memory_threshold TYPE i VALUE 85,
      gc_cpu_threshold    TYPE i VALUE 80.

ENDCLASS.

CLASS zcl_health_monitor IMPLEMENTATION.

  METHOD get_current_health.
    " Définir l'horodatage
    GET TIME STAMP FIELD rs_status-timestamp.
    rs_status-component = 'ABAP_ENVIRONMENT'.

    " Statut mémoire depuis les infos système
    " Dans ABAP Cloud: cl_abap_context_info pour les infos de base
    DATA(lv_zone) = cl_abap_context_info=>get_system_context( )-zone_id.
    rs_status-message = |System Zone: { lv_zone }|.

    " Pour des métriques détaillées : utiliser les APIs SAP BTP
    " Celles-ci sont disponibles via Cloud Foundry ou le service BTP
    rs_status-status = 'HEALTHY'.
    rs_status-memory_percent = 72. " Valeur exemple
    rs_status-cpu_percent = 45.     " Valeur exemple
  ENDMETHOD.

  METHOD check_and_alert.
    DATA(ls_health) = get_current_health( ).

    " Vérification mémoire
    IF ls_health-memory_percent > gc_memory_threshold.
      " Envoyer une alerte (via Application Logging ou Event)
      DATA(lo_log) = cl_bali_log=>create_with_header(
        header = cl_bali_header_setter=>create(
          object      = 'ZSYSTEM"
          subobject   = 'HEALTH"
          external_id = |HEALTH_CHECK_{ ls_health-timestamp }|
        )
      ).

      lo_log->add_item( cl_bali_message_setter=>create(
        severity = if_bali_constants=>c_severity_warning
        text     = |High memory usage: { ls_health-memory_percent }%|
      ) ).

      lo_log->save( ).
    ENDIF.

    " Vérification CPU
    IF ls_health-cpu_percent > gc_cpu_threshold.
      " Analogue pour le CPU
    ENDIF.
  ENDMETHOD.

ENDCLASS.

Analyse de performance et SQL Trace

App SQL Trace Analysis

L’app Fiori “SQL Trace Analysis” (App-ID: F2912) remplace le SQL Trace classique ST05 :

┌────────────────────────────────────────────────────────────────────────────┐
│  SQL Trace Analysis                                                         │
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────────┐
│  │  Active Traces                                                           │
│  │                                                                          │
│  │  User          Started          Duration    Status                       │
│  │  DEVELOPER01   14:23:15         00:05:23    ● Recording                 │
│  │  TESTUSER      13:45:00         00:30:00    ○ Stopped                   │
│  │                                                                          │
│  │  [Start New Trace]  [Stop All]  [Delete Selected]                       │
│  └─────────────────────────────────────────────────────────────────────────┘
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────────┐
│  │  Trace Results: DEVELOPER01                                              │
│  │                                                                          │
│  │  Duration    Records   Statement                                         │
│  │  ─────────────────────────────────────────────────────────────────────  │
│  │  1.234 ms    1,500    SELECT * FROM ZCUSTOMER WHERE ...                 │
│  │  0.892 ms      250    SELECT * FROM ZORDERS WHERE CUSTOMER_ID = ...     │
│  │  0.456 ms       50    SELECT * FROM ZITEMS WHERE ORDER_ID = ...         │
│  │  0.123 ms        1    UPDATE ZCUSTOMER SET LAST_ACCESS = ...            │
│  │                                                                          │
│  │  Total: 4 statements, 2.705 ms, 1,801 records                           │
│  └─────────────────────────────────────────────────────────────────────────┘
└────────────────────────────────────────────────────────────────────────────┘

SQL Trace programmatique

" Contrôler le SQL Trace programmatiquement
CLASS zcl_sql_trace_helper DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS:
      start_trace
        IMPORTING iv_user TYPE syuname DEFAULT sy-uname
        RAISING   cx_failed.

      stop_trace
        IMPORTING iv_user TYPE syuname DEFAULT sy-uname
        RAISING   cx_failed.

      analyze_trace
        IMPORTING iv_user TYPE syuname DEFAULT sy-uname
        RETURNING VALUE(rt_results) TYPE string_table.

ENDCLASS.

CLASS zcl_sql_trace_helper IMPLEMENTATION.

  METHOD start_trace.
    " Dans ABAP Cloud: Démarrer le trace via l'app Fiori
    " Programmatiquement: API cl_abap_sql_trace (si disponible)

    " Alternative: Hints de performance ABAP SQL directement dans le code
    " SELECT ... %_HINTS HANAODBC 'RESULT_CACHE"
  ENDMETHOD.

  METHOD stop_trace.
    " Arrêter le trace
  ENDMETHOD.

  METHOD analyze_trace.
    " Analyser les résultats du trace
    " En production: Lire les résultats depuis l'API Trace
  ENDMETHOD.

ENDCLASS.

Bonnes pratiques d’analyse de performance

" Optimiser les requêtes critiques en performance
CLASS zcl_performance_analyzer DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS:
      analyze_slow_queries
        RETURNING VALUE(rt_recommendations) TYPE string_table.

ENDCLASS.

CLASS zcl_performance_analyzer IMPLEMENTATION.

  METHOD analyze_slow_queries.
    " Problèmes de performance fréquents et solutions

    " 1. Index manquants
    APPEND |Problème: Full Table Scan sur ZCUSTOMER| TO rt_recommendations.
    APPEND |Solution: Créer un index secondaire sur les champs de recherche| TO rt_recommendations.

    " 2. Éviter SELECT *
    APPEND |Problème: SELECT * FROM large_table| TO rt_recommendations.
    APPEND |Solution: Sélectionner uniquement les champs nécessaires| TO rt_recommendations.

    " Exemple: Requête optimisée
    " Mauvais:
    " SELECT * FROM zcustomer INTO TABLE @DATA(lt_all).

    " Bon:
    SELECT customer_id, name, city
      FROM zcustomer
      WHERE region = @lv_region
      INTO TABLE @DATA(lt_customers).

    " 3. Éviter le problème N+1 Query
    APPEND |Problème: Boucles avec requêtes individuelles| TO rt_recommendations.
    APPEND |Solution: Utiliser JOINs ou FOR ALL ENTRIES| TO rt_recommendations.

    " Mauvais:
    " LOOP AT lt_orders INTO DATA(ls_order).
    "   SELECT SINGLE * FROM zcustomer WHERE id = ls_order-customer_id.
    " ENDLOOP.

    " Bon:
    IF lt_orders IS NOT INITIAL.
      SELECT customer_id, name
        FROM zcustomer
        FOR ALL ENTRIES IN @lt_orders
        WHERE customer_id = @lt_orders-customer_id
        INTO TABLE @DATA(lt_customers_opt).
    ENDIF.

    " 4. Utiliser les agrégations CDS View
    APPEND |Problème: Agrégation dans une boucle ABAP| TO rt_recommendations.
    APPEND |Solution: Agrégation dans CDS View ou SQL| TO rt_recommendations.
  ENDMETHOD.

ENDCLASS.

Monitoring des jobs

App Fiori : Application Jobs

L’app “Application Jobs” (App-ID: F3544) affiche tous les jobs planifiés et exécutés :

┌────────────────────────────────────────────────────────────────────────────┐
│  Application Jobs                                                           │
│                                                                             │
│  Filter: [All Jobs ▼]  Status: [All ▼]  Date: [Today ▼]  [Search]         │
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────────┐
│  │  Job Name              Template          Status       Start/End         │
│  │  ─────────────────────────────────────────────────────────────────────  │
│  │  Z_DAILY_CLEANUP_001   Z_DAILY_CLEANUP   ✓ Finished   06:00 - 06:15    │
│  │  Z_REPORT_GEN_002      Z_REPORT_GEN      ✓ Finished   07:00 - 07:45    │
│  │  Z_DATA_SYNC_003       Z_DATA_SYNC       ● Running    08:00 - ...      │
│  │  Z_MONTHLY_ARCH_004    Z_MONTHLY_ARCH    ○ Scheduled  01.03.2026 00:00 │
│  │  Z_FAILED_TASK_005     Z_DATA_IMPORT     ✗ Failed     09:00 - 09:02    │
│  │                                                                          │
│  │  [View Log]  [Restart]  [Cancel]  [Schedule New]                        │
│  └─────────────────────────────────────────────────────────────────────────┘
│                                                                             │
│  Job Details: Z_FAILED_TASK_005                                            │
│  ┌─────────────────────────────────────────────────────────────────────────┐
│  │  Error Message:                                                          │
│  │  CX_SY_OPEN_SQL_DB: Database error 1234 at SELECT from ZDATA_SOURCE     │
│  │                                                                          │
│  │  Application Log:                                                        │
│  │  09:00:01 - Job started                                                  │
│  │  09:00:15 - Processing batch 1/10                                        │
│  │  09:02:03 - ERROR: Connection to source system lost                      │
│  │  09:02:03 - Job terminated with error                                    │
│  └─────────────────────────────────────────────────────────────────────────┘
└────────────────────────────────────────────────────────────────────────────┘

Aperçu des statuts de job

Statut	Description	Action requise
Scheduled	Job planifié	Aucune
Ready	Job en attente d’exécution	Aucune
Running	Job en cours d’exécution	Monitoring
Finished	Job terminé avec succès	Vérifier le log
Failed	Job terminé en erreur	Analyser l’erreur
Canceled	Job annulé manuellement	Vérifier la cause

Monitoring de jobs programmatique

" Classe de monitoring de jobs pour ABAP Cloud
CLASS zcl_job_monitor DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    TYPES:
      BEGIN OF ty_job_info,
        job_name        TYPE cl_apj_rt_api=>ty_job_name,
        job_count       TYPE cl_apj_rt_api=>ty_job_count,
        status          TYPE string,
        start_timestamp TYPE timestamp,
        end_timestamp   TYPE timestamp,
        has_errors      TYPE abap_bool,
      END OF ty_job_info,
      ty_job_infos TYPE STANDARD TABLE OF ty_job_info WITH KEY job_name job_count.

    METHODS:
      get_jobs_by_template
        IMPORTING iv_template    TYPE cl_apj_rt_api=>ty_template_name
                  iv_from_date   TYPE d DEFAULT sy-datum - 7
        RETURNING VALUE(rt_jobs) TYPE ty_job_infos.

    METHODS:
      get_failed_jobs
        IMPORTING iv_from_date   TYPE d DEFAULT sy-datum
        RETURNING VALUE(rt_jobs) TYPE ty_job_infos.

    METHODS:
      get_job_log
        IMPORTING iv_job_name    TYPE cl_apj_rt_api=>ty_job_name
                  iv_job_count   TYPE cl_apj_rt_api=>ty_job_count
        RETURNING VALUE(rt_log)  TYPE string_table.

    METHODS:
      restart_failed_job
        IMPORTING iv_job_name    TYPE cl_apj_rt_api=>ty_job_name
                  iv_job_count   TYPE cl_apj_rt_api=>ty_job_count
        RAISING   cx_apj_rt.

ENDCLASS.

CLASS zcl_job_monitor IMPLEMENTATION.

  METHOD get_jobs_by_template.
    " Récupérer la liste des jobs depuis l'API Runtime
    TRY.
        " Parcourir le catalogue de jobs
        DATA(lt_job_catalog) = cl_apj_rt_api=>get_job_catalog( ).

        LOOP AT lt_job_catalog INTO DATA(ls_job)
          WHERE template_name = iv_template.

          " Récupérer les détails du job
          DATA(ls_job_details) = cl_apj_rt_api=>get_job_details(
            iv_job_name  = ls_job-job_name
            iv_job_count = ls_job-job_count
          ).

          " Ajouter au résultat
          APPEND VALUE #(
            job_name        = ls_job-job_name
            job_count       = ls_job-job_count
            status          = ls_job_details-status
            start_timestamp = ls_job_details-start_timestamp
            end_timestamp   = ls_job_details-end_timestamp
            has_errors      = xsdbool( ls_job_details-status = 'F' )
          ) TO rt_jobs.
        ENDLOOP.

      CATCH cx_apj_rt INTO DATA(lx_error).
        " Gérer l'erreur
        RETURN.
    ENDTRY.
  ENDMETHOD.

  METHOD get_failed_jobs.
    " Déterminer les jobs échoués
    TRY.
        DATA(lt_all_jobs) = cl_apj_rt_api=>get_job_catalog( ).

        LOOP AT lt_all_jobs INTO DATA(ls_job).
          DATA(ls_details) = cl_apj_rt_api=>get_job_details(
            iv_job_name  = ls_job-job_name
            iv_job_count = ls_job-job_count
          ).

          " Uniquement les jobs échoués
          IF ls_details-status = 'A'. " Aborted/Failed
            APPEND VALUE #(
              job_name        = ls_job-job_name
              job_count       = ls_job-job_count
              status          = 'FAILED"
              start_timestamp = ls_details-start_timestamp
              end_timestamp   = ls_details-end_timestamp
              has_errors      = abap_true
            ) TO rt_jobs.
          ENDIF.
        ENDLOOP.

      CATCH cx_apj_rt.
        RETURN.
    ENDTRY.
  ENDMETHOD.

  METHOD get_job_log.
    " Récupérer le log du job
    TRY.
        DATA(lt_messages) = cl_apj_rt_api=>get_job_log(
          iv_job_name  = iv_job_name
          iv_job_count = iv_job_count
        ).

        LOOP AT lt_messages INTO DATA(ls_msg).
          APPEND |{ ls_msg-timestamp } - { ls_msg-severity }: { ls_msg-text }|
            TO rt_log.
        ENDLOOP.

      CATCH cx_apj_rt.
        APPEND 'Log non disponible' TO rt_log.
    ENDTRY.
  ENDMETHOD.

  METHOD restart_failed_job.
    " Redémarrer un job échoué
    " Note: Le job doit être replanifié
    cl_apj_rt_api=>restart_job(
      iv_job_name  = iv_job_name
      iv_job_count = iv_job_count
    ).
  ENDMETHOD.

ENDCLASS.

ABAP Runtime Errors

App Fiori : ABAP Runtime Errors

Cette app remplace ST22 et affiche les erreurs runtime (dumps) :

┌────────────────────────────────────────────────────────────────────────────┐
│  ABAP Runtime Errors                                                        │
│                                                                             │
│  Filter: Date [14.02.2026]  User [All]  Error Type [All]  [Apply]          │
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────────┐
│  │  Time       User          Error Type              Program               │
│  │  ─────────────────────────────────────────────────────────────────────  │
│  │  10:45:23   DEVELOPER01   COMPUTE_INT_ZERODIVIDE  ZCL_CALCULATOR        │
│  │  09:12:05   TESTUSER      OBJECTS_OBJREF_NOT_ASSIGNED  ZCL_PROCESSOR   │
│  │  08:30:17   BATCHUSER     DBSQL_SQL_ERROR         ZCL_DATA_LOADER       │
│  │                                                                          │
│  │  [View Details]  [Download]  [Export to CSV]                            │
│  └─────────────────────────────────────────────────────────────────────────┘
│                                                                             │
│  Error Details: COMPUTE_INT_ZERODIVIDE                                     │
│  ┌─────────────────────────────────────────────────────────────────────────┐
│  │  Exception: CX_SY_ZERODIVIDE                                             │
│  │  Message: Division by zero                                               │
│  │                                                                          │
│  │  Source Position:                                                        │
│  │  Class: ZCL_CALCULATOR  Method: DIVIDE  Line: 45                        │
│  │                                                                          │
│  │  Variables:                                                              │
│  │  LV_NUMERATOR = 100                                                      │
│  │  LV_DENOMINATOR = 0                                                      │
│  │                                                                          │
│  │  Call Stack:                                                             │
│  │  1. ZCL_CALCULATOR=>DIVIDE                                               │
│  │  2. ZCL_ORDER_SERVICE=>CALCULATE_DISCOUNT                                │
│  │  3. ZCL_ORDER_PROCESSOR=>PROCESS                                         │
│  └─────────────────────────────────────────────────────────────────────────┘
└────────────────────────────────────────────────────────────────────────────┘

Aperçu des apps de monitoring importantes

App-ID	Nom de l’app	Objectif	Chemin URL
F5687	Health Monitoring	Santé du système	/sap/bc/ui5_ui5/sap/healthmonitoring
F2912	SQL Trace Analysis	Performance	/sap/bc/ui5_ui5/sap/sqltrace
F3544	Application Jobs	Surveillance des jobs	/sap/bc/ui5_ui5/sap/applicationjobs
F3840	Manage Background Tasks	bgPF Tasks	/sap/bc/ui5_ui5/sap/bgpf
F1734	Application Logs	Analyse des logs	/sap/bc/ui5_ui5/sap/applicationlogs
-	ABAP Runtime Errors	Analyse des dumps	/sap/bc/ui5_ui5/sap/runtimeerrors

Bonnes pratiques

Stratégie de monitoring

Domaine	Recommandation	Fréquence
Health Check	Vérification automatisée	Toutes les 5 minutes
Job Monitoring	Vérifier les jobs échoués	Quotidien
Performance	SQL Trace en cas de problèmes	À la demande
Logs	Vérifier les logs critiques	Quotidien
Runtime Errors	Analyser les dumps	À l’occurrence
Capacité	Vérifier l’utilisation des ressources	Hebdomadaire

Bonnes pratiques d’alertes

Définir des seuils : Limites claires pour Memory, CPU, Response Time
Niveaux d’escalade : Warning → Error → Critical avec notifications différentes
Éviter les faux positifs : Durée minimum avant alerte (ex. 5 minutes de CPU élevé soutenu)
Documentation : Créer des runbooks pour chaque type d’alerte
Révision régulière : Vérifier les seuils d’alerte trimestriellement

Sujets connexes

Application Logging - Implémentation détaillée du logging
Background Jobs - Planification et gestion des jobs
Tests unitaires ABAP - Tests pour un code stable
Optimisation de performance - Optimisation du code

Résumé

Le monitoring de l’ABAP Environment sur SAP BTP nécessite une approche différente de l’On-Premise :

Apps Fiori au lieu des transactions classiques (SM21, ST22, SM37)
Application Logging (BALI) pour la journalisation persistante
cl_apj_rt_api pour le monitoring programmatique des jobs
SAP Cloud ALM pour le monitoring et les alertes à l’échelle de l’entreprise
CDS Views pour vos propres tableaux de bord de monitoring

La combinaison d’apps Fiori standard, de monitoring programmatique et de Cloud ALM permet une surveillance complète de votre système ABAP Cloud.