Introducción

¡Hola comunidad!

Esta publicación es una introducción a mi aplicación iris-fhir-client en Open Exchange.

Usando Python embebido y con la ayuda de la librería fhirpy, iris-fhir-client puede conectarse a cualquier servidor FHIR abierto.
Obten información de recursos por terminal y mediante el uso de la aplicación web CSP.

¡Hola comunidad!

En esta publicación voy a explicar cómo mostrar datos en internet usando Python embebido, Marco web Python Flask y jQuery DataTable.

Mostraré los procesos desde la tabla %SYS.ProcessQuery.

Paso 1: Añade la tabla a la página HTML y escribe debajo el código javascript para mostrar los datos pasados desde app.py :

HTML

  <table id="myTable" class="table table-bordered table-striped">                 
   </table>

Javascript

¡Hola Comunidad!

Esta publicación es una introducción a mi aplicación iris-python-apps, disponible en Open Exchange y creada usando Embedded Python y Python Flask Web Framework. La aplicación muestra algunas de las funcionalidades de Python, como la ciencia de datos, el trazado de datos, la visualización de datos y la generación de códigos QR.

Características

•  Cuadro de mando de IRIS de arranque responsive

•  Vista de los detalles del cuadro de mando junto con el registro de eventos de interoperabilidad y los mensajes

•  Uso del trazado de Python desde IRIS

•  Uso de Jupyter Notebook

•  Introducción a la ciencia de datos, trazado de datos y visualización de datos

• Generación de código QR desde Python

Quizás algún día necesites utilizar Adaptive Analytics, así que aquí va un artículo sobre cómo empezar a desarrollar un dashboard (cuadro de mando) en Tableau conectando con el cubo de Atscale.

Preparación del PC

Necesitas conectar un driver. Yo uso Cloudera Hive. Puedes descargar el driver desde:
https://www.cloudera.com/downloads/connectors/hive/odbc/2-6-1.html

Tienes que registrarte, puedes hacerlo gratis. Necesitas descargar la versión correcta para tu sistema operativo.

La instalación es sencilla.

Preparación de AtScale

Publicación del proyecto

Para conectar a un cubo desde Tableau, tienes que publicar primero un proyecto con los cubos que te interesen.

Para publicarlo, ve a PROJECTS > "Project name" > DRAFT "Project name" > PUBLISH

La pandemia que afectó al mundo en 2020 hizo a todo el mundo seguir las noticias y los datos relacionados con la COVID-19. ¿Por qué no aprovechar la oportunidad para crear algo sencillo y fácil de usar, para seguir el número de vacunaciones a nivel mundial?

Para afrontar este reto, estoy usando los datos proporcionados por Our World in Data- Investigación y datos para progresar antes los mayores problemas del mundo. Han dedicado un repositorio en GitHub con los datos de la COVID-19, y he tomado los datos de vacunación para ayudarme con mi rastreador.

Hola a todos,

con este artículo, me gustaría mostrar lo fácil y dinámicamente que puede ser configurada nuestra herramienta de Alerta y Monitorización de Sistema (SAM, del inglés System Alerting and Monitoring). El caso de uso podría ser el de un flujo de aprovisionamiento CI/CD ágil y rápido, donde queráis ejecutar vuestros tests unitarios y de estrés, y podáis ver rápidamente si los tests tuvieron éxito o cómo están estresando el sistema y tu aplicación ( el API de SAM en el backend de InterSystems IRIS es extensible para tu implementación APM). 

¡Hola a todos!

Quiero compartir un proyecto personal que comenzó con una simple solicitud en el trabajo:

     ¿Es posible saber cuántas licencias de Caché estamos usando?

A continuación veremos cómo mostrar una lista de métricas de ejemplo disponibles a través del servicio /api/monitor.

En el artículo anterior, echamos un vistazo al servicio que expone las métricas de IRIS en formato Prometheus. Veamos cómo configurar y ejecutar IRIS preview release 2019.4 en un contenedor y listar las métricas disponibles.

Asumimos que tienes Docker instalado. Si no es así, descárgalo e instálalo para tu sistema operativo :)

Si ya te resulta familiar trabajar con IRIS y contenedores Docker, puedes saltar directamente al Paso 2. Mostrar métricas.

Paso 1. Descargar and ejecutar IRIS en un contenedor

Sigue las instrucciones de Preview Distributions para descargar la Clave de Licencia Preview y una imagen Docker IRIS. Por ejemplo, yo he escogido InterSystems IRIS for Health 2019.4.

Sigue las instrucciones de First Look InterSystems Products in Docker Containers.

Este es el proceso que hemos seguido para cargar la imagen Docker. El comando docker load tardará algunos instantes en completarse.

 $ pwd
 /Users/myhome/Downloads/iris_2019.4
 
 $ ls
 InterSystems IRIS for Health (Container)_2019.4.0_Docker(Ubuntu)_12-31-2019.ISCkey irishealth-2019.4.0.379.0-docker.tar
 
 $ docker load -i irishealth-2019.4.0.379.0-docker.tar
 762d8e1a6054: Loading layer [==================================================>] 91.39MB/91.39MB
 e45cfbc98a50: Loading layer [==================================================>] 15.87kB/15.87kB
 d60e01b37e74: Loading layer [==================================================>] 12.29kB/12.29kB
 b57c79f4a9f3: Loading layer [==================================================>] 3.072kB/3.072kB
 b11f1f11664d: Loading layer [==================================================>] 73.73MB/73.73MB
 22202f62822e: Loading layer [==================================================>] 2.656GB/2.656GB
 50457c8fa41f: Loading layer [==================================================>] 14.5MB/14.5MB
 bc4f7221d76a: Loading layer [==================================================>] 2.048kB/2.048kB
 4db3eda3ff8f: Loading layer [==================================================>] 1.491MB/1.491MB
 Loaded image: intersystems/irishealth:2019.4.0.379.0
 
 $ docker images
 REPOSITORY TAG IMAGE ID CREATED SIZE
 intersystems/irishealth 2019.4.0.379.0 975a976ad1f4 3 weeks ago 2.83GB

Por simplicidad, copia la licencia al directorio que utilizaremos como almacenamiento persistente y renómbrala a iris.key;

 $ mkdir -p /Users/myhome/iris/20194
 $ cp 'InterSystems IRIS for Health (Container)_2019.4.0_Docker(Ubuntu)_12-31-2019.ISCkey' /Users/myhome/iris/20194/iris.key
 
 $ cd /Users/myhome/iris/20194
 $ ls
 iris.key

Ejecuta IRIS utilizando el directorio que acabamos de crear para almacenamiento persistente;

 $ docker run --name iris --init --detach --publish 52773:52773 --volume `pwd`:/external intersystems/irishealth:2019.4.0.379.0 --key /external/iris.key
 
 $ docker ps -a
 CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
 009e52c121f0 intersystems/irishealth:2019.4.0.379.0 "/iris-main --key /e…" About a minute ago Up About a minute (healthy) 0.0.0.0:52773->52773/tcp iris

Genial! Ya puedes conectarte al Portal de Gestión del contenedor que tenemos en ejecución. Entraremos con login/password SuperUser/SYS; a continuación, el sistema te pedirá que cambies la contraseña por defecto.

Dirígete a la configuración de las Aplicaciones Web. System > Security Management > Web Applications

Verás una aplicación web llamada /api/monitor, éste es el servicio que expone las métricas de IRIS.

No tienes que hacer nada adicional para que el servicio retorne las métrica, simplemente funciona! :)

Paso 2. Mostrar métricas

En artículos posteriores, emplearemos este endpoint desde Prometheus o SAM para recoger las métricas a intervalos específicos. Pero por ahora, vamos a mostrar la lista completa de métricas disponibles para la instancia. Una forma simple de hacerlo en Linux y OSX es lanzando un HTTP GET a través del comando curl;

 $ curl localhost:52773/api/monitor/metrics
 :
 :
 iris_cpu_usage 0
 iris_csp_activity{id="127.0.0.1:52773"} 56
 iris_csp_actual_connections{id="127.0.0.1:52773"} 8
 iris_csp_gateway_latency{id="127.0.0.1:52773"} .588
 iris_csp_in_use_connections{id="127.0.0.1:52773"} 1
 iris_csp_private_connections{id="127.0.0.1:52773"} 0
 iris_csp_sessions 1
 iris_cache_efficiency 35.565
 :
 :
 Y la lista continúa...

Otra forma muy útil de hacerlo es utilizar la aplicación Postman. Si tienes instalado Postman, puedes enviar un HTTP GET y examinar las métricas devueltas.

Resumen

Esto es todo por ahora. En el próximo artículo, comenzaremos a recuperar los datos desde Prometheus y veremos un ejemplo de un cuadro de mando de Grafana.

Lista completa de métricas para el contenedor de prueba

Un sistema de producción tendrá muchas más métricas disponibles. Como podéis ver por algunas de las etiquetas, por ejemplo {id="IRISLOCALDATA"} hay métricas que son definidas por base de datos o por CPU por el tipo de proceso{id="CSPDMN"}.

 iris_cpu_pct{id="CSPDMN"} 0
 iris_cpu_pct{id="CSPSRV"} 0
 iris_cpu_pct{id="ECPWorker"} 0
 iris_cpu_pct{id="GARCOL"} 0
 iris_cpu_pct{id="JRNDMN"} 0
 iris_cpu_pct{id="LICENSESRV"} 0
 iris_cpu_pct{id="WDSLAVE"} 0
 iris_cpu_pct{id="WRTDMN"} 0
 iris_cpu_usage 0
 iris_csp_activity{id="127.0.0.1:52773"} 57
 iris_csp_actual_connections{id="127.0.0.1:52773"} 8
 iris_csp_gateway_latency{id="127.0.0.1:52773"} .574
 iris_csp_in_use_connections{id="127.0.0.1:52773"} 1
 iris_csp_private_connections{id="127.0.0.1:52773"} 0
 iris_csp_sessions 1
 iris_cache_efficiency 35.850
 iris_db_expansion_size_mb{id="ENSLIB"} 0
 iris_db_expansion_size_mb{id="HSCUSTOM"} 0
 iris_db_expansion_size_mb{id="HSLIB"} 0
 iris_db_expansion_size_mb{id="HSSYS"} 0
 iris_db_expansion_size_mb{id="IRISAUDIT"} 0
 iris_db_expansion_size_mb{id="IRISLOCALDATA"} 0
 iris_db_expansion_size_mb{id="IRISSYS"} 0
 iris_db_expansion_size_mb{id="IRISTEMP"} 0
 iris_db_free_space{id="ENSLIB"} .055
 iris_db_free_space{id="HSCUSTOM"} 2.3
 iris_db_free_space{id="HSLIB"} 113
 iris_db_free_space{id="HSSYS"} 9.2
 iris_db_free_space{id="IRISAUDIT"} .094
 iris_db_free_space{id="IRISLOCALDATA"} .34
 iris_db_free_space{id="IRISSYS"} 6.2
 iris_db_free_space{id="IRISTEMP"} 20
 iris_db_latency{id="ENSLIB"} 0.030
 iris_db_latency{id="HSCUSTOM"} 0.146
 iris_db_latency{id="HSLIB"} 0.027
 iris_db_latency{id="HSSYS"} 0.018
 iris_db_latency{id="IRISAUDIT"} 0.017
 iris_db_latency{id="IRISSYS"} 0.020
 iris_db_latency{id="IRISTEMP"} 0.021
 iris_db_max_size_mb{id="ENSLIB"} 0
 iris_db_max_size_mb{id="HSCUSTOM"} 0
 iris_db_max_size_mb{id="HSLIB"} 0
 iris_db_max_size_mb{id="HSSYS"} 0
 iris_db_max_size_mb{id="IRISAUDIT"} 0
 iris_db_max_size_mb{id="IRISLOCALDATA"} 0
 iris_db_max_size_mb{id="IRISSYS"} 0
 iris_db_max_size_mb{id="IRISTEMP"} 0
 iris_db_size_mb{id="HSLIB",dir="/usr/irissys/mgr/hslib/"} 1321
 iris_db_size_mb{id="HSSYS",dir="/usr/irissys/mgr/hssys/"} 21
 iris_db_size_mb{id="ENSLIB",dir="/usr/irissys/mgr/enslib/"} 209
 iris_db_size_mb{id="IRISSYS",dir="/usr/irissys/mgr/"} 113
 iris_db_size_mb{id="HSCUSTOM",dir="/usr/irissys/mgr/HSCUSTOM/"} 11
 iris_db_size_mb{id="IRISTEMP",dir="/usr/irissys/mgr/iristemp/"} 21
 iris_db_size_mb{id="IRISAUDIT",dir="/usr/irissys/mgr/irisaudit/"} 1
 iris_db_size_mb{id="IRISLOCALDATA",dir="/usr/irissys/mgr/irislocaldata/"} 1
 iris_directory_space{id="HSLIB",dir="/usr/irissys/mgr/hslib/"} 53818
 iris_directory_space{id="HSSYS",dir="/usr/irissys/mgr/hssys/"} 53818
 iris_directory_space{id="ENSLIB",dir="/usr/irissys/mgr/enslib/"} 53818
 iris_directory_space{id="IRISSYS",dir="/usr/irissys/mgr/"} 53818
 iris_directory_space{id="HSCUSTOM",dir="/usr/irissys/mgr/HSCUSTOM/"} 53818
 iris_directory_space{id="IRISTEMP",dir="/usr/irissys/mgr/iristemp/"} 53818
 iris_directory_space{id="IRISAUDIT",dir="/usr/irissys/mgr/irisaudit/"} 53818
 iris_disk_percent_full{id="HSLIB",dir="/usr/irissys/mgr/hslib/"} 10.03
 iris_disk_percent_full{id="HSSYS",dir="/usr/irissys/mgr/hssys/"} 10.03
 iris_disk_percent_full{id="ENSLIB",dir="/usr/irissys/mgr/enslib/"} 10.03
 iris_disk_percent_full{id="IRISSYS",dir="/usr/irissys/mgr/"} 10.03
 iris_disk_percent_full{id="HSCUSTOM",dir="/usr/irissys/mgr/HSCUSTOM/"} 10.03
 iris_disk_percent_full{id="IRISTEMP",dir="/usr/irissys/mgr/iristemp/"} 10.03
 iris_disk_percent_full{id="IRISAUDIT",dir="/usr/irissys/mgr/irisaudit/"} 10.03
 iris_ecp_conn 0
 iris_ecp_conn_max 2
 iris_ecp_connections 0
 iris_ecp_latency 0
 iris_ecps_conn 0
 iris_ecps_conn_max 1
 iris_glo_a_seize_per_sec 0
 iris_glo_n_seize_per_sec 0
 iris_glo_ref_per_sec 7
 iris_glo_ref_rem_per_sec 0
 iris_glo_seize_per_sec 0
 iris_glo_update_per_sec 2
 iris_glo_update_rem_per_sec 0
 iris_journal_size 2496
 iris_journal_space 50751.18
 iris_jrn_block_per_sec 0
 iris_jrn_entry_per_sec 0
 iris_jrn_free_space{id="WIJ",dir="default"} 50751.18
 iris_jrn_free_space{id="primary",dir="/usr/irissys/mgr/journal/"} 50751.18
 iris_jrn_free_space{id="secondary",dir="/usr/irissys/mgr/journal/"} 50751.18
 iris_jrn_size{id="WIJ"} 100
 iris_jrn_size{id="primary"} 2
 iris_jrn_size{id="secondary"} 0
 iris_license_available 31
 iris_license_consumed 1
 iris_license_percent_used 3
 iris_log_reads_per_sec 5
 iris_obj_a_seize_per_sec 0
 iris_obj_del_per_sec 0
 iris_obj_hit_per_sec 2
 iris_obj_load_per_sec 0
 iris_obj_miss_per_sec 0
 iris_obj_new_per_sec 0
 iris_obj_seize_per_sec 0
 iris_page_space_per_cent_used 0
 iris_phys_mem_per_cent_used 95
 iris_phys_reads_per_sec 0
 iris_phys_writes_per_sec 0
 iris_process_count 29
 iris_rtn_a_seize_per_sec 0
 iris_rtn_call_local_per_sec 10
 iris_rtn_call_miss_per_sec 0
 iris_rtn_call_remote_per_sec 0
 iris_rtn_load_per_sec 0
 iris_rtn_load_rem_per_sec 0
 iris_rtn_seize_per_sec 0
 iris_sam_get_db_sensors_seconds .000838
 iris_sam_get_jrn_sensors_seconds .001024
 iris_system_alerts 0
 iris_system_alerts_new 0
 iris_system_state 0
 iris_trans_open_count 0
 iris_trans_open_secs 0
 iris_trans_open_secs_max 0
 iris_wd_buffer_redirty 0
 iris_wd_buffer_write 0
 iris_wd_cycle_time 0
 iris_wd_proc_in_global 0
 iris_wd_size_write 0
 iris_wd_sleep 10002
 iris_wd_temp_queue 42
 iris_wd_temp_write 0
 iris_wdwij_time 0
 iris_wd_write_time 0
 iris_wij_writes_per_sec 0

En InterSystems IRIS 2019.1.4 se incluye ya el servicio /api/monitor, que permite acceder a métricas de IRIS en formato Prometheus.

Esto es una gran noticia para aquellos interesados en utilizar métricas de IRIS como parte de su solución de monitorización y alertas. Este servicio (API) es un componente del nuevo System Alerting and Monitoring (SAM) que se liberará en próximas versiones de InterSystems IRIS.

Sin embargo, no es necesario esperar a que se libere System Alerting and Monitoring (SAM) para empezar a planificar y probar esta API para monitorizar tus instancias de IRIS. En próximos artículos trataremos en profundidad las métricas disponibles, su significado y también construiremos cuadros de mando de ejemplo interactivos. Pero en primer lugar, vamos a comenzar con algunas cuestiones básicas.

IRIS (y Caché) está siempre capturando decenas de métricas sobre sí mismo y la plataforma en la que está ejecutándose. Siempre han existido diferentes maneras de capturar estas métricas para monitorizar IRIS o Caché. En la práctica no muchas instalaciones utilizan las soluciones incluidas en IRIS / Caché. Por ejemplo, el History Monitor ha estado disponible desde hace tiempo como base de datos histórica de rendimiento y utilización del sistema. Sin embargo, no había una manera demasiado obvia de aprovechar estas métricas en tiempo real.

Las soluciones construidas sobre la plataforma InterSystems IRIS están pasando de una sola aplicación monolítica ejecutándose en unas pocas instancias en las propias instalaciones de una organización a ser soluciones distribuidas desplegadas en cualquier parte. Para muchos casos de uso, las opciones de monitorización de IRIS existentes no se terminan de adaptar a estos nuevos paradigmas. Para solventar este problema, en lugar de reinventar la rueda, InterSystems utilizará soluciones conocidas y bien probadas del mundo open source para monitorización y alertas.

Prometheus

Prometheus es una solución open source de monitorización muy conocida y ampliamente adoptada. Dispone de una gran variedad de plugins. Está diseñada para poder trabajar en entornos de cloud pero también resulta igual de útil para aplicaciones desplegadas en nuestras propias instalaciones. Los plugins incluyen sistemas operativos, servidores web como Apache y otras muchas aplicaciones. Prometheus se utiliza generalmente junto con un cliente front-end o de presentación, como por ejemplo Grafana, que provee una interfaz gráfica que es extremadamente adaptable a nuestras necesidades.

Grafana

Grafana es también open source. Conforme esta serie de artículos progrese, pasaremos ejemplos de plantillas de cuadros de mando para escenarios típicos. Podrás utilizar esos ejemplos como base para diseñar los cuadros de mando que te interesen.

El gran potencial de estas herramientas surge cuando combinas las métricas de IRIS en el contexto de las métricas de tu propia solución. Desde los componentes de la plataforma donde se ejecuta, el sistema operativo, IRIS y especialmente cuando además se añade instrumentación para monitorizar tus propias aplicaciones.

¿No he visto esto antes en algún sitio?

Monitorizar IRIS / Caché con Prometheus y Grafana no es algo nuevo. Se han utilizado estas aplicaciones durante años. Si buscas en la Comunidad de Desarrolladores el término "Prometheus" encontrarás otros artículos como por ejemplo estos excelentes artículos de Mikhail Khomenko que muestran cómo exponer métricas de Caché para utilizarlas con Prometheus.

La diferencia es que ahora la API /api/monitor está incluida y habilitada por defecto. No necesitas incluir código para exponer estas métricas.

Introducción rápida a Prometheus

A continuación vamos a hacer una primera orientación rápida a Prometheus y su terminología. Vamos a verlo a alto nivel y a preparar el trabajo de base que servirá para dejar la puerta abierta para que penséis cómo visualizar y consumir las métricas de IRIS o de otras fuentes.

Prometheus funciona obteniendo datos en formato de serie temporal expuestos por aplicaciones a través de una URL (por ejemplo la API de /api/monitor). Existen librerías de exportadores y clientes para muchos lenguajes, frameworks y aplicaciones open source — por ejemplo para servidores web como Apache, distintos sistemas operativos, docker, Kubernetes, bases de datos y ahora IRIS —.

Los exportadores se utilizan para instrumentalizar aplicaciones y servicios de manera que expongan (hagan accesible) las métricas en una URL. Los componentes estándar como los servidores web, bases de datos y demás se soportan por los exportadores core. Existen otros muchos exportadores open source disponibles en la comunidad Prometheus.

Terminología Prometheus

Estos son algunos términos que vamos a manejar:

• Los destinos son aquellos servicios que quieres monitorizar, como un servidor, una aplicación o un servicio como Apache, IRIS o tu propia aplicación.
• Prometheus interroga a estos destinos utilizando HTTP para obtener métricas en formato de serie temporal.
• Los datos en formato de serie temporal se exponen por las aplicaciones, como por ejemplo IRIS, o través de exportadores.
• Los exportadores se utilizan para aquellos elementos que no podemos controlar como por ejemplo métricas del kernel de Linux.
• Los datos en formato de serie temporal resultantes se almacenan localmente en el servidor de Prometheus en una base de datos**.
• La base de datos de series temporales se puede consultar utilizando un lenguaje de consulta optimizado para ello PromQL. Utilizaremos este lenguaje para crear alertas o desde una aplicación cliente como Grafana para mostrar las métricas en un cuadro de mando.

** Spoiler Alert! Por razones de seguridad, escalabilidad, alta disponibilidad y eficiencia, en la nueva solución System Alerting and Monitoring (SAM) la base de datos utilizada para almacenar las series temporales de Prometheus será InterSytems IRIS! El acceso a la base de datos de Prometheus (IRIS) será transparente y no supondrá ninguna circunstancia especial para acceder desde otras aplicaciones como Grafana.

Modelo de datos de Prometheus

Las métricas que retorna la API /api/monitor están en formato Prometheus. Prometheus utiliza un formato simple basado en una métrica por línea:

 [ (time n, value n), ....]

Estas métricas pueden etiquetarse como parejas clave-valor. Las etiquetas son una forma muy potente de filtrar métricas y dimensiones. Por ejemplo, vamos a examinar esta métrica del servicio/api/monitor que retorna la cantidad de espacio libre para journal:

 iris_jrn_free_space{id="WIJ",dir=”/fast/wij/"} 401562.83

El identificador indica qué métrica es y de dónde viene:

iris_jrn_free_space

Se pueden utilizar diferentes etiquetas para decorar las métricas, y así utilizarlas a la hora de filtrar y consultar. En el ejemplo, podemos ver el WIJ y el directorio donde se guarda el propio WIJ:

id="WIJ",dir="/fast/wij/"

Y finalmente, observamos también un valor: 401562.83 (MB).

¿Qué métricas tenemos disponibles para IRIS?

En la documentación aparece la lista de las métricas disponibles. Aunque también puedes simplemente consultar la API en el endpoint /api/monitor/metricspara que te devuelva la lista de las métricas.

¿Qué debería monitorizar?

Ten en cuenta los siguientes puntos a la hora de pensar cómo debes monitorizar tus sistemas y aplicaciones.

Cuando te sea posible, utiliza métricas que afecten a los usuarios:

• A los usuarios no les importa que una de tus máquinas esté corta de CPU.
• A los usuarios sí que les importa si el servicio que utilizan es lento o está teniendo errores.
• En tus cuadros de mando principales céntrate en métricas de alto nivel que impacten directamente en los usuarios.

Evita construir una pantalla llena de gráficas en tus cuadros de mando:

• Los humanos, en general, no podemos asimilar demasiados datos a la vez.
• Simplifica y utiliza por ejemplo un cuadro de mando por servicio.

Piensa en términos de servicios, no de máquinas:

• Una vez hayas aislado un problema a un servicio, podrás profundizar y ver realmente cuál es la máquina que presenta el problema.

Referencias

Documentación y descargas: Prometheus y Grafana.

@Murray Oldfield presentó una sesión sobre SAM (incluyendo Prometheus y Grafana) en el pasado InterSystems Global Summit 2019. Encontrarás más información en InterSystems Learning Services buscando el término "System Alerting and Monitoring Made Easy".

Nos complace anunciar la disponibilidad de HealthShare 2019.1.

Con esta versión, HealthShare ofrece: