Presentación de los recursos de InfoSphere Streams 2.0, Parte 1: Supervisión de aplicaciones con métricas

Ejemplos de métricas de C++ y SPL

Nuevo para IBM® InfoSphere® Streams 2.0, la introducción del componente de métricas proporciona acceso en tiempo de ejecución a las estadísticas del sistema y a las definidas por el usuario que pueden utilizarse para supervisar el funcionamiento interno de su aplicación Streams. Este artículo destaca el nuevo sistema de métricas y describe cómo acceder y utilizar las métricas del sistema y las definidas por el usuario como parte de su aplicación Streams.

Chris Howard, Big Data Solution Architect, Office of the CTO, IBM

Chris HowardChris Howard ha estado con IBM desde 1998 y actualmente es arquitecto de soluciones centrado en soluciones de Datos Grandes (InfoSphere Streams e InfoSphere BigInsights) como parte de la oficina de CTO en IBM Software Group. En su rol anterior, fue gerente del EMEA Stream Computing Centre en Dublín y responsable por el desarrollo de soluciones de clientes para la solución de procesamiento de flujo de IBM: IBM InfoSphere Streams. Es un Chartered Fellow del British Computer Society.



25-06-2012

Introducción

Este artículo describe las capacidades del nuevo sistema de métricas accesible para los desarrolladores de InfoSphere Streams. Introducido con el release de Streams 2.0, el sistema de métricas ofrece acceso en tiempo de ejecución a las métricas específicas de la aplicación, proporcionando la capacidad de supervisar externamente las estadísticas de interés de la aplicación. Proporcionamos diversas muestras en el Streams Processing Language y C++.

Este artículo ha sido escrito para los desarrolladores de componentes de Streams y programadores de aplicaciones que cuentan con habilidades en lenguaje de programación y C++. Utilice este artículo como una referencia; las muestras provistas pueden examinarse y ejecutarse para demostrar las técnicas descritas. Para ejecutar las muestras, se debe tener un conocimiento práctico general en programación de Streams.

Para ejecutar las muestras se requiere un producto Red Hat Enterprise Linux® con InfoSphere Streams V2.0 o posterior.


Visión general del sistema de métricas

El tiempo de ejecución de Streams 2.0 ofrece la capacidad de consultar varias métricas de aplicaciones y hacer uso de estos datos como parte de un trabajo de ejecución de Streams o mediante una herramienta externa o programas (como streamtool). El acceso a estas métricas proporciona una gama de usos, ya sea una simple supervisión de aplicaciones o adaptaciones más sofisticadas en tiempo real a implementar en la aplicación en ejecución (relevo de carga, por ejemplo).

El acceso a estas métricas se proporciona mediante APIs de tiempo de ejecución. Esto permite la recuperación de una serie de datos de métricas relacionados con el número o tuplas procesadas, eliminadas, en cola, etc., para los puertos de entrada y salida en el nivel de Streams Operator o Processing Element (PE).

El tiempo de ejecución de Streams proporciona la capacidad de dar soporte a dos tipos de métricas principales:

  • Métricas del sistema— Datos del contador predefinidos para Operadores y PEs. Puede incluir datos como el número de tuplas de Streams presentados por un puerto de operador.
  • Métricas definidas por usuario— Métricas definidas por desarrollador, implementadas en el nivel del operador y utilizadas para informar valores de la aplicación de interés.

En las siguientes secciones se entra en más detalles sobre los diversos tipos de métricas y los detalles de su implementación.

Tipos de datos de métricas

Los datos de Streams registrados, suministrados por el sistema o definidos por el usuario, pueden ser de uno de los tres tipos básicos de datos de métricas. Dichos tipos proporcionan algún contexto acerca de la clase de datos de contador representados por la métrica. La lista de tipos de datos de métricas se presenta a continuación.

  • Contadores— Se utilizan para representar valores de métrica que aumentan (o disminuyen) con el tiempo, por ejemplo el número de tuplas procesadas por un puerto de entrada de operador.
  • Calibradores— Se utilizan para representar un valor en un punto en el tiempo y pueden configurarse para cualquier valor como el número de puntuación de ventana actualmente en la cola.
  • Tiempo— Se utiliza para representar una marca de fecha / hora, puede utilizarse para registrar la hora en que un evento particular ocurrió en la aplicación de Streams.

Las métricas del sistema suministradas por el tiempo de ejecución son del tipo de datos fijos (normalmente contadores o calibradores), donde la selección del tipo de datos de la métrica depende del desarrollador al implementar una métrica definida por el usuario.


Métricas del sistema

Incluida de manera predeterminada como parte del tiempo de ejecución de Streams, las métricas del sistema permiten acceder a un rango de valores que permiten conocer el funcionamiento interno de una aplicación Streams. En el nivel de la aplicación, APIs están disponibles para un acceso provisto por el operador a las métricas asociadas a dicho operador y el elemento de procesamiento que contiene el operador; el alcance para acceso a las métricas está limitado localmente.

Tener este nivel de conocimientos sobre el funcionamiento interno de un operador y el elemento de procesamiento de contenedor permite a una aplicación potencialmente adaptar su comportamiento basado en los valores de la métrica. Dentro de la propia aplicación, oportunidades para cargar tuplas de relevo basadas en tasas de datos excesivos, o controlar un estado de los operadores con base en la cantidad de tuplas procesadas son las posibles opciones. Externamente a la aplicación, scripts o programas pueden sondear la aplicación más amplia o las métricas disponibles en nivel de sistema, ya sea para supervisión básica o para reaccionar en nivel de sistema a eventos que el sistema de métricas registra.

Las métricas del sistema vienen en dos variedades: métricas en nivel de operador y métricas en nivel de PE. En la sección siguiente, exploraremos cada una de ellas.

Métricas del operador — Métricas para puertos de entrada y salida

Puertos de subprocesos

Un puerto de subproceso permite a un puerto de entrada de operador ejecutar en su propio subproceso separado. Las tuplas llegan a cada puerto de entrada llamado en un subproceso de ejecución separado, incluso si el operador se fusiona con otros. Esto permite aumentar la ejecución simultánea de los operadores, especialmente en la misma partición / PE Consulte la Tabla 1 para una lista de dichas métricas disponibles solo para puertos de subprocesos.

Las métricas del sistema en nivel de operador permiten una inspección refinada del procesamiento que un operador específico ejecuta. Es posible consultar una variedad de valores de métricas para cada puerto de entrada y salida asociado a un operador — que van desde cuentas de tuplas de datos (procesado, eliminado, en cola) hasta detalles de tuplas de puntuación como números de tipos (ventana, final) y estados (procesado, en cola).

El acceso a este nivel de detalle para un operador individual permite una capacidad de diagnóstico importante. Así, es posible diagnosticar problemas de una aplicación, como cuellos de botella de desempeño, mediante supervisión de las tuplas eliminadas o en cola en los puertos de subprocesos (vea la barra lateral "Threaded ports").

Figura 1. Métricas en nivel de PE
Métricas en nivel de PE

Obtener acceso a las métricas en nivel de operador se hace mediante la clase OperatorContext y su función de miembro getMetrics() , que retorna un objeto OperatorMetrics . Para acceder al contexto de los operadores primero es necesario una llamada a la función de miembro getContext() del operador.

Clase SPL::Metric

La clase SPL::Metric utilizada para representar un objeto de métrica, suministra una variedad de funciones de miembro para acceder al nombre, descripción y clase de la métrica, además de obtener el valor actual. Consulte Recursos para obtener los enlaces a la documentación de la API de C++ de SPL Operator Runtime.

Las llamadas a los métodos getInputPortMetric(port, metric) y getOutputPortMetric(port, metric) de la clase OperatorMetrics permiten acceso directo a las métricas de los puertos de entrada y salida, respectivamente. Aquí, port es el número del índice del puerto y metric es el nombre de la métrica a ser retornada (mediante OperatorMetrics::InputPortMetricName u OperatorMetrics::OutputPortMetricName, dependiendo del tipo de métrica solicitada).

Listado 1. Declarando el archivo de encabezado de la métrica (_h.cgt)
...
  
    private:
      // Members 
    
        // Note const required for getInputPortMetric and getOutputPortMetric
        Metric const & numTuplesProcessed; 

    ...
Listado 2. Acceder a la métrica mediante el operador primitivo (_cpp.cgt)
// Constructor
    MY_OPERATOR::MY_OPERATOR()
      : numTuplesProcessed(getContext().getMetrics()\
          .getInputPortMetric(0, OperatorMetrics::nTuplesProcessed))
    {
    }    
	    
    // Tuple processing for non-mutating ports
    void MY_OPERATOR::process(Tuple const & tuple, uint32_t port)
    {

        // Declare variable to store the metrics current value    
        int64_t nProcessedValue;

        ...

        nProcessedValue = numTuplesProcessed.getValueNoLock();
    
        ...
    }

NOTA: Observe cómo se realiza la llamada a getInputPortMetric() como parte de la lista de inicialización del constructor y no en el cuerpo del constructor. Esto es porque la función de miembro retorna un valor de const y es necesario que se ejecute durante la inicialización y no en la asignación.

A continuación se da un ejemplo en SPL, esta vez para el número de tuplas en cola en un puerto de entrada. Implementado como parte del evento onTuple en un operador personalizado de SPL, esto permite que se tome una acción alternativa basada en la excesiva cantidad de tuplas en la cola del puerto de entrada.

Listado 3. Ejemplo de operador getInputPortMetric de SPL
    // Declare metric value
    mutable int64 nQueuedValue = 0; 	
	
    // Return the number of Tuples Queued for input port 0
    getInputPortMetricValue(0u, Sys.nTuplesQueued, nQueuedValue);

La tabla siguiente muestra detalles de las métricas en nivel de operador disponibles; lista el nombre, alcance y la descripción de la métrica.

Tabla 1. Métricas en nivel de operador suministradas por el sistema
NombreAlcanceDescripción
nTuplesProcessedpor puerta de entradaNúmero de tuplas procesadas (contador)
nTuplesDropped*por puerta de entradaNúmero de tuplas eliminadas (contador)
nTuplesQueued*por puerta de entradaNúmero de tuplas en cola (calibrador)
nWindowPunctsProcessedpor puerta de entradaNúmero de puntuaciones de ventana procesadas (contador)
nFinalPunctsProcessedpor puerta de entradaNúmero de puntuaciones finales procesadas (contador)
nWindowPunctsQueued*por puerta de entradaNúmero de puntuaciones de ventana en cola (calibrador)
nFinalPunctsQueued*por puerta de entradaNúmero de puntuaciones finales en cola (calibrador)
queueSize*por puerta de entradaTamaño de cola para el puerto o 0 si no hay cola (calibrador)
nTuplesSubmittedpor puerto de salidaNúmero de tuplas presentadas (contador)
nWindowPunctsSubmittedpor puerto de salidaNúmero de puntuaciones de ventana presentadas (contador)
nFinalPunctsSubmittedpor puerto de salidaNúmero de puntuaciones finales presentadas (contador)

Las métricas marcadas con * están disponibles solo para los puertos de entrada configurados con threadedPort. Una llamada a getInputPortMetric() retorna 0 para non-threadedPorts.

Métricas de PE — Métricas para puertos de entrada y salida

Las métricas en nivel de elemento de procesamiento son semejantes a las métricas en nivel de operador. Cuando se trata de métricas en nivel de operador, nos preocupamos con valores específicos para el operador en contexto, mientras que las métricas en nivel de elemento de procesamiento se relacionan con todos los operadores que implementan flujos que cruzan el límite de PE.

La Figura 2 ilustra en detalles este concepto de límite. Aquí se representa un elemento de procesamiento individual que contiene cuatro operadores. Cada operador tiene un número de puertos de entrada y salida. Cuando se trata de métricas en nivel de PE, solo los puertos de entrada y salida que cruzan el límite de PE están disponibles para consultas (por ejemplo, el número de tuplas procesadas desde el puerto de entrada 0, 1 y 2, además del número de tuplas presentadas al puerto de salida 0). Aunque el puerto de entrada 1 de PE alimenta a los operadores 1 y 2, las tuplas solo se cuentan una vez al consultar el número de tuplas procesadas en el puerto de entrada 1 de PE.

Figura 2. Métricas en nivel de PE
Métricas en nivel de PE

La Tabla 2 muestra una correlación entre las métricas en nivel de operador y de PE. Observe que los puertos internos del PE que no cruzan el límite solo son accesibles en nivel de operador.

Tabla 2. Correlación entre puertos del Operador y del PE
OperadorPuerto del operadorPuerto del PEAlcance del acceso
Operador 1Puerto de Entrada 0Puerto de Entrada 0Operador y PE
Puerto de Entrada 1Puerto de Entrada 1Operador y PE
Puerto de Salida 0n/aSolo Operador
Operador 2Puerto de Entrada 0Puerto de Entrada 1Operador y PE
Puerto de Entrada 1Puerto de Entrada 2Operador y PE
Puerto de Salida 0n/aSolo Operador
Operador 3Puerto de Entrada 0n/aSolo Operador
Puerto de Salida 0n/aSolo Operador
Operador 4Puerto de Entrada 0n/aSolo Operador
Puerto de Salida 0Puerto de Salida 0Operador y PE

Para llegar al numero total de tuplas procesadas por el PE, es necesario sumar los números de tuplas individuales para cada puerto de entrada de PE (puertos 0, 1 y 2). Un PE que contiene un solo operador (por ejemplo, utilizando "partition exlocation placement") retornará el mismo resultado para las métricas en nivel de PE y de operador.

Además de las cuentas de tuplas y puntuación suministradas en el nivel de operador, las métricas de PE se extienden para cubrir las tasas de bytes de las tuplas en los puertos de entrada y salida, así como los detalles del estado de la conexión para los puertos de salida (número de conexiones rotas, por ejemplo). Este tipo de métrica puede ser útil para comprobar enlaces fallidos entre PEs que puedan requerir algún nivel de atención. Las métricas en nivel de PE siguen el mismo mecanismo de acceso que las métricas de operador, pero en lugar de consultar mediante el contexto de operador, se utiliza getPE() para retornar un manejador al PE.

La tabla siguiente muestra detalles de las métricas en nivel de PE disponibles; lista el nombre, alcance y la descripción de la métrica.

Tabla 3. Métricas en nivel de PE suministradas por el sistema
NombreAlcanceDescripción
nTuplesProcessedpor puerta de entradaNúmero de tuplas procesadas (contador)
nTupleBytesProcessedpor puerta de entradaNúmero de bytes procesados por el puerto (contador)
nWindowPunctsProcessedpor puerta de entradaNúmero de puntuaciones de ventana procesadas (contador)
nFinalPunctsProcessedpor puerta de entradaNúmero de puntuaciones finales procesadas (contador)
nTuplesSubmittedpor puerto de salidaNúmero de tuplas presentadas (contador)
nTupleBytesSubmittedpor puerto de salidaNúmero de bytes de tupla presentada (contador)
nWindowPunctsSubmittedpor puerto de salidaNúmero de puntuaciones de ventana presentadas (contador)
nFinalPunctsSubmittedpor puerto de salidaNúmero de puntuaciones finales presentadas (contador)
nBrokenConnectionspor puerto de salidaNúmero de conexiones rotas que ocurrieron en el puerto (contador)
nRequiredConnectingpor puerto de salidaNúmero de conexiones necesarias actualmente conectando el puerto (calibrador)
nOptionalConnectingpor puerto de salidaNúmero de conexiones opcionales actualmente conectando el puerto (calibrador)

Métricas definidas por el usuario

Además de las métricas integradas suministradas por el tiempo de ejecución de Streams, también es posible añadir métricas personalizadas. Estas se comportan como las métricas del sistema, sin embargo le permiten que exhiba externamente sus propios valores importantes que le interesan.

Cuándo utilizar una métrica personalizada

Las métricas personalizadas proporcionan un excelente mecanismo para exponer elementos de interés que normalmente estarían ocultos en el código del operador de Streams. Siempre que sea necesario saber el tamaño de un búfer, la longitud de una lista enlazada o la fecha y hora del último punto de comprobación del operador, puede utilizarse una métrica personalizada. Las métricas personalizadas ofrecen una alternativa en vez de recurrir a un operador receptor o a un registro de depuración.

Definiendo métricas personalizadas

Las métricas personalizadas pueden declararse estáticamente mediante el modelo de operador o pueden crearse dinámicamente en el tiempo de ejecución. El tiempo de ejecución del lenguaje SPL que se ejecuta automáticamente crea una instancia para las métricas definidas en el modelo de operador. Para crear métricas personalizadas en tiempo de ejecución, utilice la función de miembro createCustomMetric(name, description, kind) .

Independientemente de la manera en que se declaran, las métricas personalizados pueden accederse mediante la función de miembro getCustomMetricByName(name) de la clase OperatorMetric . Tiene libertad para actualizar el valor de una métrica personalizada a cualquier momento después de su creación. Su valor puede actualizarse mediante las funciones setValue(newValue) y incrementValue(incValue) . Detalles adicionales pueden encontrarse en IBM Streams Processing Language Runtime API Documentation.

Definiendo una métrica personalizada como parte del modelo de operador de Streams

Un modelo de operador es un documento XML utilizado para describir un operador primitivo de C++ o Java™ . El documento está constituido por cuatro elementos importantes:

  • Contexto
  • Parámetros
  • Puertos de entrada
  • Puertos de salida

El elemento de contexto describe propiedades globales aplicables al operador que no están enlazadas con determinados parámetros o puertos del operador. Este elemento también captura definiciones comunes que pueden ser referidas en entradas posteriores del modelo de operador.

La edición del modelo de operador se realiza mediante el Streams Studio Editor en vistas en árbol o modo XML de origen. La Figura 3 muestra la vista en árbol, y el Listado 4 muestra el correspondiente fragmento XML para el operador personalizado.

Figura 3. Edición de la vista en árbol del modelo de operador
Edición de la vista en árbol del modelo de operador
Listado 4. Muestra XML (parcial) del modelo de operador
...        
  <metrics>
    <metric>
      <name>myCount</name>
      <description>A new metric defined via the operator model</description>
      <kind>Counter</kind>
    </metric>
  </metrics>
  ...

Como se muestra, el acceso a las métricas personalizados es una operación sencilla utilizando la clase OperatorContext y su función de miembro getMetrics() . El ejemplo siguiente muestra cómo se puede acceder a la recién creada métrica personalizada MyCount y asignarle un valor.

Listado 5. Declarando el archivo de encabezado de la métrica (_h.cgt)
    ...
  
    private: // Members 
    
        Metric & myCountStatic;
    ...
Listado 6. Acceder a la métrica mediante el operador primitivo (_cpp.cgt)
// Constructor
    MY_OPERATOR::MY_OPERATOR()
      : myCountStatic(getContext().getMetrics().getCustomMetricByName("myCount"))
    {
    }    
	    
    // Tuple processing for non-mutating ports
    void MY_OPERATOR::process(Tuple const & tuple, uint32_t port)
    {

        ...

        // Set the Custom Metric to an arbitrary value
        myCountStatic.setValue(someValue);

        // Increment the Metric by 10
        myCountStatic.incrementValue(10);
    
        ...
    }

Otras dos útiles funciones de miembro para la clase SPL::OperatorMetrics son hasCustomMetric(name) y getCustomMetricNames(), que le permiten consultar por la existencia de las métricas personalizadas definidas en el modelo del operador y retornar sus nombres.

Creando una métrica personalizada en tiempo de ejecución

Como alternativa a predefinir una métrica personalizada como parte del modelo de operador, también es posible crear dinámicamente nuevas métricas mediante la función createCustomMetric(name, description, kind) , donde "kind" es uno de los siguientes:

  • Metric::Counter
  • Metric::Gauge
  • Metric::Time

Nuestro ejemplo final, muestra cómo crear dinámicamente una nueva métrica en tiempo de ejecución sin previamente tener que definirla como parte de un modelo de operador. Una vez definida, el mismo mecanismo se utiliza para configurar o aumentar el valor de la nueva métrica.

Listado 7. Declarando el archivo de encabezado de la métrica (_h.cgt)
    ...
  
    private: // Members 
    
        Metric & myCountDynamic;
    ...
Listado 8. Acceder a la métrica mediante el operador primitivo (_cpp.cgt)
// Constructor
    MY_OPERATOR::MY_OPERATOR()
      : myCountDynamic(getContext().getMetrics().createCustomMetric("myCountDynamic",\
          "A description for a dynamic metric", Metric::Counter))
    {
    }    
	    
    // Tuple processing for non-mutating ports
    void MY_OPERATOR::process(Tuple const & tuple, uint32_t port)
    {

        ...

        // Set the Custom Metric to an arbitrary value
        myCountDynamic.setValue(someValue);

        // Increment the Metric by 10
        myCountDynamic.incrementValue(10);
    
        ...
    }

NOTA: Aunque hemos proporcionado una descripción de nuestra métrica anterior, este valor no se escogerá ni exhibirá al inspeccionar el Operador / PE en el gráfico de la instancia de Streams Studio. Las métricas creadas mediante el modelo de operador tienen sus descripciones añadidas al archivo de lenguaje de descripción (.adl), de la aplicación, que luego se utiliza para construir el gráfico en vivo. Este no es el caso para las métricas creadas en tiempo de ejecución.


Accediendo a las métricas

La sección final del artículo examina la variedad de técnicas disponibles para inspeccionar datos de métricas sin tener que recurrir al desarrollo personalizado y a diferentes APIs de tiempo de ejecución

Accediendo a métricas mediante el comando streamtool capturestate

El comando streamtool capturestate puede utilizarse para capturar el estado actual de los hosts y trabajos del sistema en una instancia de Streams, además de las métricas de desempeño disponibles para dichos hosts y trabajos. Para referencia, el comando retorna resultados en formato XML, por lo que estos datos pueden ser analizados y utilizados en sus propios scripts para impulsar nuevas acciones si es necesario.

El esquema se encuentra disponible en el archivo streams-install-directory/schema/streamsInstanceState.xsd.

Utilice el siguiente comando para capturar información de métricas de desempeño para los trabajos en ejecución en una instancia de Streams: streamtool capturestate --select jobs=metrics.

Al solicitar información de métricas de desempeño, la salida del comando incluye información adicional acerca de los PEs, operadores y puertos. El Listado 9 exhibe una muestra de la información de métricas para un operador.

Listado 9. Muestra de salida XML de streamtool capturestate
...
  <operator name="PrimOp">
    <metric name="myCountDynamic" lastChangeObserved="1329912395" userDefined="true">
      <metricValue xsi:type="streams:longType" value="65"/>
    </metric>
    <metric name="myCount" lastChangeObserved="1329912395" userDefined="true">

      <metricValue xsi:type="streams:longType" value="1065"/>
    </metric>
    <inputPort index="0" name="BeaconStream">
      <metric name="nTuplesProcessed" lastChangeObserved="1329912395" userDefined="false">
        <metricValue xsi:type="streams:longType" value="782"/>
      </metric>

    ...
    </inputPort>
    ...
  </operator>

Observe como nuestras métricas personalizadas son mostradas con sus valores actuales El campo lastChangeObserved entrega el tiempo basado en el número de segundos desde la época. Para información adicional sobre el uso de comandos y de cómo interpretar la salida, consulte la sección sobre métricas de desempeño en Streams Administration and Installation Guide (Chapter 10, Monitoring and managing IBM InfoSphere Streams).

Accediendo a las métricas mediante Streams Studio — Visualización de las métricas

Streams Studio contiene una vista de métricas que le permite supervisar métricas asociadas con una instancia de ejecución. La vista de métricas se divide en dos componentes principales:

  • Una vista de navegación basada en árbol, en el panel izquierdo, donde se selecciona el elemento cuyas métricas se desea ver
  • Una vista de métricas basada en tablas, en el panel derecho, que contiene las métricas para el elemento seleccionado en el lado izquierdo

La navegación en el árbol del panel izquierdo le permite seleccionar hosts, trabajos, PEs, operadores y puertos de entrada y salida para inspección; en el panel derecho se muestran los detalles de las métricas capturadas para la entidad seleccionada. Las figuras a continuación muestran dos ejemplos de las métricas exhibidas para nuestras métricas personalizadas y, después, en nivel de puerto de entrada de un operador.

Figura 4. Métricas personalizadas de operador
Métricas personalizadas de operador
Figura 5. Métricas de puerto de entrada de operador
Métricas de puerto de entrada de operador

Este es solo un pequeño ejemplo de la abundancia de información disponible mediante la vista de métricas Una exploración detallada de la vista queda fuera del alcance de este artículo, no obstante, la publicación InfoSphere Streams Studio Installation and User's Guide proporciona una descripción detallada en el Capítulo 9 — Monitoring running SPL applications.

Accediendo a las métricas mediante Streams Studio — Gráfico de instancia

Nuestra opción final para inspeccionar métricas de tiempo de ejecución es proporcionada mediante la vista de gráfico de instancia de Streams Studio. La vista de gráfico de instancia muestra una topología dinámica de las aplicaciones SPL que se ejecutan en una instancia de Streams. La vista puede personalizarse para cambiar la manera de exhibir la topología de las aplicaciones en ejecución.

Recopilación de información de métricas

Para habilitar la recopilación de información de métricas, haga clic en el ícono Collect Metrics Information Collect metrics Information icon.

Puede elegir qué tipo de elementos de Streams (como operadores, PEs y trabajos) incluir en el gráfico y cómo agrupar y pintar estos elementos. También es posible habilitar y configurar la recopilación de información de métricas de tiempo de ejecución para operadores y PEs en la vista de Gráfico de Instancia.

En la Figura 6 se puede ver un ejemplo de las métricas de tiempo de ejecución que se exhiben al poner el mouse sobre un determinado operador. La ventana flotante muestra el nombre del operador, métricas como tuplas entrantes y tuplas salientes, seguidas por las métricas declaradas anteriormente. Observe que las métricas creadas en tiempo de ejecución no tienen descripciones asociadas a ellas.

De nuevo, Este es solo un pequeño ejemplo de la información disponible mediante la vista de métricas. Consulte InfoSphere Streams Studio Installation and User's Guide para información adicional sobre supervisión de métricas bajo el gráfico de instancia.

Figura 6. Ventana flotante mostrando métricas de tiempo de ejecución de operador
Ventana flotante mostrando métricas de tiempo de ejecución de operador

Conclusión

Esperamos que este artículo le haya presentado el uso de métricas con InfoSphere Streams. Ya sea que esté buscando conocimientos sobre las operaciones de su aplicación en ejecución o que tenga una necesidad específica para exponer contadores claves, el sistema de métricas le proporciona una manera flexible para aprovechar estos datos.

La manera más fácil de saber más es probarlo usted mismo. Armado con estos fragmentos de código, construya su propio operador y experimente con la variedad de sistemas y parámetros personalizados colocados a su disposición. Si desea obtener más información o si tiene alguna pregunta sobre cualquier tema tratado en este artículo, no dude en enviar una pregunta al foro de Streams (consulte Recursos.

Reconocimientos

Muchas gracias a Mark Mendell por su ayuda y revisión de este artículo.

Recursos

Aprender

Obtener los productos y tecnologías

  • Descargue una versión de prueba de InfoSphere Streams y aprenda cómo implementar sus propias métricas.
  • Construya su próximo proyecto de desarrollo con software de prueba IBM, disponible para descarga directamente de developerWorks.
  • Ahora usted puede utilizar DB2 gratuitamente. Descargue DB2 Express-C, una versión sin costo del DB2 Express Edition para la comunidad, que ofrece los mismos recursos de datos esenciales que el DB2 Express Edition y que proporciona una base sólida para desarrollar e implementar aplicaciones.

Comentar

Comentarios

developerWorks: Ingrese

Los campos obligatorios están marcados con un asterisco (*).


¿Necesita un IBM ID?
¿Olvidó su IBM ID?


¿Olvidó su Password?
Cambie su Password

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. La información en su propio perfil (nombre, país/región y nombre de la empresa) se muestra al público y acompañará a cualquier contenido que publique, a menos que opte por la opción de ocultar el nombre de su empresa. Puede actualizar su cuenta de IBM en cualquier momento.

Toda la información enviada es segura.

Elija su nombre para mostrar



La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

Los campos obligatorios están marcados con un asterisco (*).

(Por favor elija un nombre de 3 - 31 caracteres.)

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


Toda la información enviada es segura.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Information mgmt
ArticleID=822430
ArticleTitle=Presentación de los recursos de InfoSphere Streams 2.0, Parte 1: Supervisión de aplicaciones con métricas
publish-date=06252012