Cómo invocar la API de análisis de volcado de subprocesos

En este mundo moderno, los volcados de subprocesos todavía se analizan en un modo tedioso y manual, es decir, debe ponerse en contacto con el equipo de DevOps, pedirles que le envíen los volcados de subprocesos, luego le enviarán los volcados de subprocesos por correo, luego usted cargará el volcados en una herramienta de análisis de volcado de subprocesos, entonces debe aplicar su inteligencia para analizarlo. No existe una forma programática de analizar los volcados de subprocesos de manera proactiva. Por lo tanto, para eliminar esta molestia, fastthread.io está introduciendo una API RESTful para analizar los volcados de subprocesos. Con una línea de comando CURL, puede analizar los volcados de subprocesos al instante.

Aquí hay algunos casos de uso en los que esta API puede ser extremadamente útil.

Caso de uso 1: Análisis automático de causa raíz

La mayoría de DevOps invoca un simple ping Http o herramientas APM para monitorear el estado de las aplicaciones. Este ping es bueno para detectar si la aplicación está activa o no. Las herramientas APM son excelentes para informar que la CPU de la aplicación aumentó en ‘x%’, la utilización de la memoria aumentó en ‘y%’, el tiempo de respuesta se redujo en ‘z’ milisegundos. No informará qué causó que la CPU se disparara, qué causó que aumentara la utilización de la memoria, qué causó que el tiempo de respuesta se degradara. Si puede configurar el trabajo de Cron para capturar volcados de subprocesos/registros de GC en un intervalo periódico e invocar nuestra API REST, aplicamos nuestros patrones inteligentes y algoritmos de aprendizaje automático para identificar instantáneamente la causa raíz del problema.

Ventaja 1: Cada vez que ocurre este tipo de problema de producción, debido al calor del momento, el equipo de DevOps recicla los servidores sin capturar los volcados de subprocesos y los registros de GC. Debe capturar volcados de subprocesos y registros de GC en el momento en que ocurre el problema, para diagnosticar el problema. En esta nueva estrategia, no tiene que preocuparse por eso, porque su trabajo cron está capturando volcados de subprocesos/registros de GC en intervalos periódicos e invocando la API REST, todos sus volcados de subprocesos/registros de GC se archivan en nuestros servidores.

Ventaja 2: A diferencia de las herramientas APM que afirman agregar menos del 3 % de los gastos generales, cuando en realidad agrega múltiples pliegues, la belleza de esta estrategia es: no agrega ningún gasto general (o gastos generales insignificantes). Porque el análisis completo de los volcados de subprocesos/GCeasy se realiza en nuestros servidores y no en sus servidores de producción.

Caso de uso 2: Pruebas de rendimiento

Cuando realiza pruebas de rendimiento, es posible que desee realizar volcados de subprocesos/registros de GC periódicamente y analizarlos a través de la API. En caso de que el recuento de subprocesos supere un umbral o si hay demasiados subprocesos ESPERANDO o si alguno de los subprocesos está BLOQUEADO durante un período prolongado o si el bloqueo no se libera o se realizan actividades frecuentes de GC completas o el tiempo de pausa del GC supera los umbrales, debe obtener la visibilidad en ese momento y lugar. Debe analizarse antes de que el código llegue a la producción. En tal circunstancia, esta API será muy útil.

Caso de uso 3: Integración continua

Como parte de la integración continua, se recomienda encarecidamente ejecutar pruebas de rendimiento. Los volcados de subprocesos/registros de GC deben capturarse y pueden analizarse mediante la API. Si la API informa de algún problema, la compilación puede fallar. De esta forma, puede detectar la degradación del rendimiento justo durante el tiempo de confirmación del código en lugar de detectarla en los laboratorios de rendimiento o en producción.

¿Cómo invocar la API de análisis de volcado de subprocesos?

Invocar la API de análisis de volcado de subprocesos es extremadamente simple:

1.) Registro con nosotros. Le enviaremos por correo electrónico la clave API. Este es un proceso de configuración único. Nota: Si ha comprado versión empresarial con API, no tienes que registrarte. Se le proporcionará la clave API como parte de las instrucciones de instalación.
2.) Publique una solicitud HTTP en https://api.fastthread.io/fastthread-api?apiKey={API_KEY_SENT_IN_EMAIL}
3.) El cuerpo de la solicitud HTTP debe contener el volcado de subprocesos que debe analizarse. Puede enviar un volcado de subprocesos o varios volcados de subprocesos en la misma solicitud.
4.) La respuesta HTTP se devolverá en formato JSON. JSON tiene varias estadísticas importantes sobre el volcado de subprocesos. El elemento principal para buscar en la respuesta JSON es: “problema”. La API aplica varios patrones de análisis de volcado de subprocesos inteligentes y, si detecta algún problema, lo informará en este elemento de “problema”.

comando RIZAR

Suponiendo que su archivo de volcado de subprocesos se encuentra en “./my-thread-dump.txt”, entonces el comando CURL para invocar la API es:

curl -X POST --data-binary @./my-thread-dump.txt https://api.fastthread.io/fastthread-api?apiKey={API_KEY_SENT_IN_EMAIL} --header "Content-Type:text"

¿No puede ser más simple que eso? ¿no es así?

Compresión

Thread Dump son bastante grandes en tamaño. Para un procesamiento rápido y eficiente, le recomendamos que comprima y envíe los archivos de volcado de subprocesos. Cuando está comprimiendo el volcado de subprocesos, debe pasar el elemento ‘Codificación de contenido’ en el elemento de encabezado HTTP o en el parámetro de URL.

Supongamos que está comprimiendo el archivo de volcado de subprocesos en formato ‘zip’, luego puede invocar la API con el elemento de encabezado HTTP

curl -X POST --data-binary @./my-thread-dump.zip "https://api.fastthread.io/fastthread-api?apiKey={API_KEY_SENT_IN_EMAIL}" --header "Content-Type:text" --header "Content-Encoding:zip"

o también puede invocar la API con el elemento ‘Codificación de contenido’ en el parámetro de URL

curl -X POST --data-binary @./my-thread-dump.zip "https://api.fastthread.io/fastthread-api?apiKey={API_KEY_SENT_IN_EMAIL}&Content-Encoding=zip" --header "Content-Type:text"

Admitimos los siguientes formatos de compresión:

cremallera, gz, xz, z, lzma, desinflar, sz, lz4, zstd, bz2, alquitrán

Puede utilizar el de su elección. Cualquiera que sea el formato de compresión que utilizó para comprimir el volcado de almacenamiento dinámico, debe pasarse en el elemento ‘Codificación de contenido’.

Otras herramientas

También puede invocar la API utilizando cualquier herramienta de cliente de servicio web como: SOAP UI, Postman Browser Plugin,…..

cartero-ft.png

Fig: Publicación de volcados de subprocesos a través del complemento PostMan

Respuesta de muestra

{
  "problem": [
    {
      "level": "SEVERE",
      "description": "8 thread are looping on same lines of code. If threads loop infinitely on the same lines of code, CPU consumption will start to spike up"
    }
  ],
  "threadsRemainingInWaitingState": [
    {
      "method": "java.lang.Object.wait(Native Method)",
      "threadCount": 3,
      "threads": "Reference Handler, Dispatcher-Thread-2, Finalizer"
    },
    {
      "method": "sun.misc.Unsafe.park(Native Method)",
      "threadCount": 2,
      "threads": "New Relic RPM Connection Service, New Relic Retransformer"
    }
  ],
  "threadDumpReport": [
    {
      "timestamp": "2016-03-03 10:37:28",
      "JVMType": " 64-Bit Server VM (23.7-b01 mixed mode)",
      "threadState": [
        {
          "state": "RUNNABLE",
          "threadCount": 28,
          "threads": "Attach Listener, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-B85-9, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-H87-3, InvoiceGeneratedQC-H87-1, InvoiceGeneratedQC-B85-9, Service Thread, C2 CompilerThread1, C2 CompilerThread0, Signal Dispatcher, main, VM Thread, GC task thread#0 (ParallelGC), GC task thread#1 (ParallelGC), GC task thread#2 (ParallelGC), GC task thread#3 (ParallelGC), GC task thread#4 (ParallelGC), GC task thread#5 (ParallelGC), GC task thread#6 (ParallelGC), GC task thread#7 (ParallelGC), GC task thread#8 (ParallelGC), GC task thread#9 (ParallelGC), GC task thread#10 (ParallelGC), GC task thread#11 (ParallelGC), GC task thread#12 (ParallelGC)"
        },
        {
          "state": "WAITING",
          "threadCount": 6,
          "threads": "Dispatcher-Thread-2, New Relic RPM Connection Service, New Relic Retransformer, Finalizer, Reference Handler, VM Periodic Task Thread"
        },
        {
          "state": "TIMED_WAITING",
          "threadCount": 4,
          "threads": "GC Daemon, New Relic Sampler Service, New Relic Deadlock Detector, New Relic Thread Service"
        }
      ],
      "repeatingStackTrace": [
        {
          "stackTrace": "stacktrace",
          "threadCount": 15,
          "threads": "VM Thread, GC task thread#0 (ParallelGC), GC task thread#1 (ParallelGC), GC task thread#2 (ParallelGC), GC task thread#3 (ParallelGC), GC task thread#4 (ParallelGC), GC task thread#5 (ParallelGC), GC task thread#6 (ParallelGC), GC task thread#7 (ParallelGC), GC task thread#8 (ParallelGC), GC task thread#9 (ParallelGC), GC task thread#10 (ParallelGC), GC task thread#11 (ParallelGC), GC task thread#12 (ParallelGC), VM Periodic Task Thread"
        },
        {
          "stackTrace": "java.lang.Thread.State: RUNNABLE
at com.buggycompany.rt.util.ItinerarySegmentProcessor.setConnectingFlight(ItinerarySegmentProcessor.java:380)
at com.buggycompany.rt.util.ItinerarySegmentProcessor.processTripType0(ItinerarySegmentProcessor.java:366)
at com.buggycompany.rt.util.ItinerarySegmentProcessor.processItineraryByTripType(ItinerarySegmentProcessor.java:254)
at com.buggycompany.rt.util.ItinerarySegmentProcessor.templateMethod(ItinerarySegmentProcessor.java:399)
...",
          "threadCount": 8,
          "threads": "InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-B85-9, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-H87-3, InvoiceGeneratedQC-H87-1, InvoiceGeneratedQC-B85-9"
        },
        {
          "stackTrace": "java.lang.Thread.State: RUNNABLE
",
          "threadCount": 5,
          "threads": "Attach Listener, Service Thread, C2 CompilerThread1, C2 CompilerThread0, Signal Dispatcher"
        },
        {
          "stackTrace": "java.lang.Thread.State: TIMED_WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for   (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)
...",
          "threadCount": 3,
          "threads": "New Relic Sampler Service, New Relic Deadlock Detector, New Relic Thread Service"
        },
        {
          "stackTrace": "java.lang.Thread.State: WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for   (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
...",
          "threadCount": 2,
          "threads": "New Relic RPM Connection Service, New Relic Retransformer"
        },
      ],
      "mostUsedMethod": [
        {
          "method": "com.buggycompany.rt.util.ItinerarySegmentProcessor.setConnectingFlight(ItinerarySegmentProcessor.java:380)",
          "threadCount": 8,
          "threads": "InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-B85-9, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-H87-3, InvoiceGeneratedQC-H87-1, InvoiceGeneratedQC-B85-9"
        },
        {
          "method": "sun.misc.Unsafe.park(Native Method)",
          "threadCount": 5,
          "threads": "New Relic RPM Connection Service, New Relic Sampler Service, New Relic Deadlock Detector, New Relic Thread Service, New Relic Retransformer"
        },
        {
          "method": "java.lang.Object.wait(Native Method)",
          "threadCount": 4,
          "threads": "Dispatcher-Thread-2, GC Daemon, Finalizer, Reference Handler"
        },
      ],
            "threadGroup": [
                {
                    "group": "DQBFacade",
                    "threadCount": 100
                },
                {
                    "group": "SectorwiseContractsFacade",
                    "threadCount": 100
                },
                {
                    "group": "SameDayVoidQC",
                    "threadCount": 100
                },
                {
                    "group": "GC task thread",
                    "threadCount": 13
                },
                {
                    "group": "DefaultQuartzScheduler_Worker",
                    "threadCount": 10
                },
            ],
      "gcThreadsCount": 14
    },
    {
      "timestamp": "2016-03-03 10:37:38",
      "JVMType": " 64-Bit Server VM (23.7-b01 mixed mode)",
      "threadState": [
        {
          "state": "RUNNABLE",
          "threadCount": 28,
          "threads": "Attach Listener, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-B85-9, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-H87-3, InvoiceGeneratedQC-H87-1, InvoiceGeneratedQC-B85-9, Service Thread, C2 CompilerThread1, C2 CompilerThread0, Signal Dispatcher, main, VM Thread, GC task thread#0 (ParallelGC), GC task thread#1 (ParallelGC), GC task thread#2 (ParallelGC), GC task thread#3 (ParallelGC), GC task thread#4 (ParallelGC), GC task thread#5 (ParallelGC), GC task thread#6 (ParallelGC), GC task thread#7 (ParallelGC), GC task thread#8 (ParallelGC), GC task thread#9 (ParallelGC), GC task thread#10 (ParallelGC), GC task thread#11 (ParallelGC), GC task thread#12 (ParallelGC)"
        },
        {
          "state": "WAITING",
          "threadCount": 6,
          "threads": "Dispatcher-Thread-2, New Relic RPM Connection Service, New Relic Retransformer, Finalizer, Reference Handler, VM Periodic Task Thread"
        },
        {
          "state": "TIMED_WAITING",
          "threadCount": 4,
          "threads": "GC Daemon, New Relic Sampler Service, New Relic Deadlock Detector, New Relic Thread Service"
        }
      ],
      "repeatingStackTrace": [
        {
          "stackTrace": "stacktrace",
          "threadCount": 15,
          "threads": "VM Thread, GC task thread#0 (ParallelGC), GC task thread#1 (ParallelGC), GC task thread#2 (ParallelGC), GC task thread#3 (ParallelGC), GC task thread#4 (ParallelGC), GC task thread#5 (ParallelGC), GC task thread#6 (ParallelGC), GC task thread#7 (ParallelGC), GC task thread#8 (ParallelGC), GC task thread#9 (ParallelGC), GC task thread#10 (ParallelGC), GC task thread#11 (ParallelGC), GC task thread#12 (ParallelGC), VM Periodic Task Thread"
        },
        {
          "stackTrace": "java.lang.Thread.State: RUNNABLE
at com.buggycompany.rt.util.ItinerarySegmentProcessor.setConnectingFlight(ItinerarySegmentProcessor.java:380)
at com.buggycompany.rt.util.ItinerarySegmentProcessor.processTripType0(ItinerarySegmentProcessor.java:366)
at com.buggycompany.rt.util.ItinerarySegmentProcessor.processItineraryByTripType(ItinerarySegmentProcessor.java:254)
at com.buggycompany.rt.util.ItinerarySegmentProcessor.templateMethod(ItinerarySegmentProcessor.java:399)
...",
          "threadCount": 8,
          "threads": "InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-B85-9, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-H87-3, InvoiceGeneratedQC-H87-1, InvoiceGeneratedQC-B85-9"
        },
        {
          "stackTrace": "java.lang.Thread.State: RUNNABLE
",
          "threadCount": 5,
          "threads": "Attach Listener, Service Thread, C2 CompilerThread1, C2 CompilerThread0, Signal Dispatcher"
        },
        {
          "stackTrace": "java.lang.Thread.State: TIMED_WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for   (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)
...",
          "threadCount": 3,
          "threads": "New Relic Sampler Service, New Relic Deadlock Detector, New Relic Thread Service"
        },
        {
          "stackTrace": "java.lang.Thread.State: WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for   (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
...",
          "threadCount": 2,
          "threads": "New Relic RPM Connection Service, New Relic Retransformer"
        },
      ],
      "mostUsedMethod": [
        {
          "method": "com.buggycompany.rt.util.ItinerarySegmentProcessor.setConnectingFlight(ItinerarySegmentProcessor.java:380)",
          "threadCount": 8,
          "threads": "InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-B85-9, InvoiceGeneratedQC-A99-6, InvoiceGeneratedQC-H87-6, InvoiceGeneratedQC-H87-3, InvoiceGeneratedQC-H87-1, InvoiceGeneratedQC-B85-9"
        },
        {
          "method": "sun.misc.Unsafe.park(Native Method)",
          "threadCount": 5,
          "threads": "New Relic RPM Connection Service, New Relic Sampler Service, New Relic Deadlock Detector, New Relic Thread Service, New Relic Retransformer"
        },
        {
          "method": "java.lang.Object.wait(Native Method)",
          "threadCount": 4,
          "threads": "Dispatcher-Thread-2, GC Daemon, Finalizer, Reference Handler"
        },
      ],
      "gcThreadsCount": 14
    }
  ],
  "responseId": "20161025113858_4"
}

Elementos de respuesta JSON

Similar Posts

Leave a Reply

Your email address will not be published.