ABAP Cloud Debugging: Herramientas y Técnicas 2025

El debugging en ABAP Cloud es diferente al de Classic ABAP. Esta guía te muestra las nuevas herramientas y técnicas.

¿Qué es diferente en ABAP Cloud?

❌ Ya NO funciona

• Comando debugger /h
• SAP GUI Debugger (SE38, SE80)
• Statement BREAK-POINT
• Debugging de Dynpros
• Acceso directo a BD en el debugger

✅ Nuevas herramientas

• ADT Debugger (Eclipse)
• ABAP Console (cl_demo_output)
• Feed Reader (Jobs de fondo)
• Application Log (BAL)
• SQL Trace (Rendimiento)

1. ADT Debugger (Herramienta principal)

Iniciar debugger

Método 1: Establecer breakpoint

1. En ADT: Doble clic en número de línea → Breakpoint (punto azul)
2. Ejecutar programa (F9 o Preview)
3. Debugger se detiene en breakpoint

Método 2: Run As → ABAP Application (Debug)

1. Clic derecho en clase/programa
2. Debug As → ABAP Application

Layout del debugger

┌─────────────────────────────────┐
│  Code (línea actual marcada)    │
├─────────────────────────────────┤
│  Variables (valores de vars)    │
├─────────────────────────────────┤
│  Breakpoints (todos los bp)     │
├─────────────────────────────────┤
│  Call Stack (historial llamadas)│
└─────────────────────────────────┘

Atajos más importantes

Inspeccionar variables

METHOD calculate.
  DATA(lv_a) = 5.
  DATA(lv_b) = 3.
  DATA(lv_result) = lv_a + lv_b.  " Breakpoint aquí

  " En la pestaña Variables:
  " lv_a = 5
  " lv_b = 3
  " lv_result = 8
ENDMETHOD.

Cambiar variables:

1. Clic derecho en variable → Change Value
2. Ingresar nuevo valor
3. Continuar debugging con valor cambiado

Watchpoints

Se detiene cuando la variable cambia:

1. Clic derecho en variable → Toggle Watchpoint
2. El debugger se detiene en cada cambio

Breakpoints condicionales

Solo detenerse cuando se cumple la condición:

1. Clic derecho en breakpoint → Breakpoint Properties
2. Condition: lv_id = '12345'
3. Solo se detiene cuando lv_id tiene este valor

2. ABAP Console (Output durante desarrollo)

En lugar de WRITE o salidas de debug:

METHOD process_data.
  " Salida simple
  cl_demo_output=>display( 'Iniciando procesamiento' ).

  " Mostrar variable
  cl_demo_output=>write( |Customer ID: { lv_customer_id }| ).

  " Mostrar tabla
  cl_demo_output=>write( lt_customers ).

  " Salida final
  cl_demo_output=>display( ).
ENDMETHOD.

Output:

• Aparece en la pestaña Console en ADT
• ¡Solo usar en desarrollo!
• En producción: Usar Application Log

Ventajas:

• ✅ Más rápido que debugger
• ✅ Para estructuras de datos complejas
• ✅ Permanece en el log (se puede hacer scroll)

3. Logging con Application Log

Para código productivo:

METHOD process_order.
  TRY.
      " Crear log
      DATA(lo_log) = cl_bali_log=>create_with_header(
        header = cl_bali_header_setter=>create(
          object      = 'ZORDERS'
          subobject   = 'PROCESS'
          external_id = |Order { iv_order_id }|
        )
      ).

      " Mensaje informativo
      lo_log->add_item(
        item = cl_bali_free_text_setter=>create(
          severity = if_bali_constants=>c_severity_information
          text     = |Procesando pedido { iv_order_id }|
        )
      ).

      " Procesamiento...

      " Mensaje de éxito
      lo_log->add_item(
        item = cl_bali_free_text_setter=>create(
          severity = if_bali_constants=>c_severity_status
          text     = 'Pedido procesado exitosamente'
        )
      ).

      " Guardar log
      cl_bali_log_db=>get_instance( )->save_log( log = lo_log ).

    CATCH cx_bali_runtime INTO DATA(lx_error).
      " Manejo de errores
  ENDTRY.
ENDMETHOD.

Ver log:

• Transacción SLG1 (Clásico)
• App Fiori: “Application Logs”

Niveles de severidad:

• c_severity_error - Error (rojo)
• c_severity_warning - Advertencia (amarillo)
• c_severity_information - Info (azul)
• c_severity_status - Estado (verde)

4. SQL Trace (Debugging de rendimiento)

Problema: Encontrar SELECTs lentos

Activar SQL Trace

En ADT:

1. Run → Run Configurations
2. Pestaña Trace Requests
3. Activar SQL Trace
4. Ejecutar programa

Analizar trace

Se abre SQL Console:

SELECT * FROM kna1
  Duration: 1.2s  ❌ ¡LENTO!
  Rows: 1,000,000

SELECT name1 FROM kna1
  WHERE kunnr = '12345'
  Duration: 0.001s  ✅ Rápido
  Rows: 1

Optimización:

• ❌ Evitar SELECT *
• ❌ FOR ALL ENTRIES con tabla vacía
• ✅ Campos explícitos
• ✅ WHERE en campos indexados

5. Feed Reader (Jobs de fondo)

Problema: Debuggear jobs de fondo

Configuración

1. Iniciar job (App Fiori / SM37)
2. En ADT: Window → Show View → Feed Reader
3. Ingresar URL del feed:

   https://<system>/sap/bc/adt/runtime/traces/abaplogs

Output

Feed Reader muestra:

• Outputs de Console
• Application Logs
• Errores de runtime

¡Actualizaciones en vivo mientras el job se ejecuta!

6. Estrategias de debugging sin debugger

Estrategia 1: Unit Tests

En lugar de debuggear: escribir test

METHOD test_calculate_discount.
  " Given
  DATA(lv_amount) = 1000.

  " When
  DATA(lv_discount) = zcl_pricing=>calculate_discount( lv_amount ).

  " Then
  cl_abap_unit_assert=>assert_equals(
    act = lv_discount
    exp = 100
    msg = |Expected 100, got { lv_discount }|  " ¡Info de debug!
  ).
ENDMETHOD.

Ventaja: Reproducible, automatizado

Estrategia 2: Assertions defensivas

METHOD process_order.
  " Verificar precondición
  ASSERT iv_order_id IS NOT INITIAL.

  " Lógica de negocio
  DATA(lv_customer) = get_customer( iv_order_id ).

  " Verificar postcondición
  ASSERT lv_customer IS BOUND.
ENDMETHOD.

En Production: ASSERT se ignora (solo activo en modo Debug)

Mejor para Production: Exceptions

IF lv_customer IS NOT BOUND.
  RAISE EXCEPTION TYPE zcx_customer_not_found.
ENDIF.

Estrategia 3: Framework de Logging

Wrapper de logging propio:

CLASS zcl_logger DEFINITION.
  PUBLIC SECTION.
    CLASS-METHODS log
      IMPORTING iv_level TYPE string DEFAULT 'INFO'
                iv_text  TYPE string.
ENDCLASS.

CLASS zcl_logger IMPLEMENTATION.
  METHOD log.
    " En Dev: Console
    IF sy-sysid = 'DEV'.
      cl_demo_output=>write( |[{ iv_level }] { iv_text }| ).
    ELSE.
      " En Prod: Application Log
      " ... Código BAL ...
    ENDIF.
  ENDMETHOD.
ENDCLASS.

" Uso
zcl_logger=>log( iv_level = 'DEBUG'
                 iv_text  = |Procesando cliente { lv_id }| ).

7. Escenarios de debug frecuentes

Escenario 1: Exception en RAP

Problema: La validación falla, ¿pero por qué?

METHOD validateIsbn.
  READ ENTITIES OF zi_book IN LOCAL MODE
    ENTITY Book
      FIELDS ( Isbn )
      WITH CORRESPONDING #( keys )
    RESULT DATA(lt_books).

  LOOP AT lt_books INTO DATA(ls_book).
    " Output de debug
    cl_demo_output=>write( |Verificando ISBN: { ls_book-Isbn }| ).

    IF strlen( ls_book-Isbn ) <> 13.
      cl_demo_output=>write( 'ISBN inválido - longitud incorrecta' ).

      APPEND VALUE #( ... ) TO reported-book.
    ENDIF.
  ENDLOOP.

  cl_demo_output=>display( ).
ENDMETHOD.

Escenario 2: CDS View devuelve datos incorrectos

Estrategia:

1. SQL Console: Consultar CDS View directamente
2. Data Preview: En ADT clic derecho en View → Open With → Data Preview
3. Verificar tablas fuente: ¿Están correctos los datos brutos?

Escenario 3: Problema de rendimiento

Procedimiento:

1. Activar SQL Trace
2. Identificar SELECTs lentos
3. ABAP Console: Registrar timestamps

DATA(lv_start) = cl_abap_context_info=>get_system_time( ).

" Operación lenta
SELECT ... INTO TABLE lt_data.

DATA(lv_end) = cl_abap_context_info=>get_system_time( ).
cl_demo_output=>write( |Duración: { lv_end - lv_start } µs| ).

8. Mejores prácticas de debugging

✅ HACER

1. Breakpoints con moderación (¡no 50 de ellos!)
2. Breakpoints condicionales para datasets grandes
3. Unit Tests en lugar de debug en vivo
4. Logging en código productivo
5. SQL Trace para rendimiento

❌ NO HACER

1. Debuggear en Production (¡solo como último recurso!)
2. Dejar BREAK-POINT en el código
3. Output de Console en producción
4. Usar solo el debugger como herramienta

9. Resumen de herramientas

Resumen

Flujo de trabajo de debugging ABAP Cloud:

1. Escribir Unit Tests
   ↓ (si el test falla)
2. Usar ADT Debugger
   ↓ (¿problema de rendimiento?)
3. Activar SQL Trace
   ↓ (¿producción?)
4. Analizar Application Log

Cambio de mentalidad:

• Classic ABAP: Debugger-First
• ABAP Cloud: Test-First, Logging, luego Debugger

Ver también:

• ABAP Unit Testing
• Optimización de rendimiento ABAP Cloud
• Tutorial RAP Parte 3: Mejores prácticas

¡Happy Debugging!