#Monitoramento

0 Seguidores · 23 Postagens

Monitoramento é um processo de controle e gerenciamento de desempenho e disponibilidade de aplicações de software.

Artigo Heloisa Paiva · Set. 12, 2025 3m read

Uma coisa que aprendi ao longo dos anos é que, não importa o quão aprimorada seja a lógica do seu aplicativo, o desempenho do banco de dados acabará por determinar o sucesso ou fracasso da experiência do usuário. Trabalhando com o InterSystems IRIS, recentemente vivenciei isso em primeira mão. Um de nossos clientes estava construindo um painel de relatórios que funcionava perfeitamente durante os testes, mas assim que o conjunto de dados de produção cresceu para milhões, os tempos de resposta ficaram extremamente lentos.

0
0 47
Artigo Heloisa Paiva · Abr. 14, 2025 10m read

Introdução

O desempenho do banco de dados tornou-se um fator crítico de sucesso em um ambiente de aplicações moderno. Portanto, identificar e otimizar as consultas SQL que consomem mais recursos é essencial para garantir uma experiência de usuário fluida e manter a estabilidade da aplicação.

Este artigo explorará uma abordagem rápida para analisar as estatísticas de execução de consultas SQL em uma instância InterSystems IRIS para identificar áreas de otimização dentro de uma macro-aplicação.

Em vez de focar no monitoramento em tempo real, configuraremos um sistema que coleta e analisa estatísticas pré-calculadas pelo IRIS uma vez por hora. Essa abordagem, embora não permita o monitoramento instantâneo, oferece um excelente compromisso entre a riqueza de dados disponíveis e a simplicidade de implementação.

Usaremos o Grafana para visualização e análise de dados, o InfluxDB para armazenamento de séries temporais e o Telegraf para coleta de métricas. Essas ferramentas, reconhecidas por seu poder e flexibilidade, nos permitirão obter uma visão clara e explorável.

Mais especificamente, detalharemos a configuração do Telegraf para recuperar estatísticas. Também configuraremos a integração com o InfluxDB para armazenamento e análise de dados, e criaremos dashboards personalizados no Grafana. Isso nos ajudará a identificar rapidamente as consultas que exigem atenção especial.

Para facilitar a orquestração e o deploy desses vários componentes, empregaremos o Docker.

logos.png

0
0 53
Artigo Heloisa Paiva · Mar. 13, 2025 12m read

Plataformas de Dados e Desempenho da InterSystems - Parte 5: Monitoramento com SNMP

Em posts anteriores, mostrei como é possível coletar métricas de desempenho histórico usando pButtons. Recorro ao pButtons primeiro porque sei que ele é instalado com todas as instâncias de Plataformas de Dados (Ensemble, Caché, ...). No entanto, existem outras maneiras de coletar, processar e exibir métricas de desempenho do Caché em tempo real, seja para monitoramento simples ou, ainda, para análises operacionais e planejamento de capacidade muito mais sofisticados. Um dos métodos mais comuns de coleta de dados é usar o SNMP (Simple Network Management Protocol).

SNMP é uma maneira padrão para o Caché fornecer informações de gerenciamento e monitoramento para uma ampla variedade de ferramentas de gerenciamento. A documentação online do Caché inclui detalhes da interface entre o Caché e o SNMP. Embora o SNMP deva 'simplesmente funcionar' com o Caché, existem alguns truques e armadilhas de configuração. Levei alguns começos falsos e ajuda de outras pessoas aqui na InterSystems para fazer o Caché se comunicar com o agente mestre SNMP do Sistema Operacional, então escrevi este post para que você possa evitar a mesma dor.

Neste post, vou detalhar a configuração do SNMP para Caché no Red Hat Linux, e você deve ser capaz de usar os mesmos passos para outras distribuições *nix. Estou escrevendo o post usando o Red Hat porque o Linux pode ser um pouco mais complicado de configurar - no Windows, o Caché instala automaticamente uma DLL para se conectar com o serviço SNMP padrão do Windows, então deve ser mais fácil de configurar.

Uma vez que o SNMP esteja configurado no lado do servidor, você pode começar a monitorar usando várias ferramentas. Vou mostrar o monitoramento usando a popular ferramenta PRTG, mas existem muitas outras - Aqui está uma lista parcial.

Observe que os arquivos MIB do Caché e Ensemble estão incluídos na pasta Caché_installation_directory/SNMP. Os arquivos são: ISC-CACHE.mib e ISC-ENSEMBLE.mib.

Posts anteriores desta série:

Comece aqui...

Comece revisando "Monitorando o Caché Usando SNMP" na documentação online do Caché..

1. Configuração do Caché

Siga os passos na seção Gerenciando SNMP no Caché na documentação online do Caché para habilitar o serviço de monitoramento do Caché e configurar o subagente SNMP do Caché para iniciar automaticamente na inicialização do Caché.

Verifique se o processo do Caché está em execução, por exemplo, olhando na lista de processos ou no sistema operacional:

ps -ef | grep SNMP
root      1171  1097  0 02:26 pts/1    00:00:00 grep SNMP
root     27833     1  0 00:34 pts/0    00:00:05 cache -s/db/trak/hs2015/mgr -cj -p33 JOB^SNMP

É só isso, a configuração do Caché está completa!

2. Configuração do sistema operacional

Há um pouco mais a fazer aqui. Primeiro, verifique se o daemon snmpd está instalado e em execução. Se não estiver, instale e inicie o snmpd.

Verifique o status do snmpd com:

service snmpd status

Inicie ou pare o snmpd com:

service snmpd start|stop

Se o SNMP não estiver instalado, você terá que instalá-lo de acordo com as instruções do sistema operacional, por exemplo: yum -y install net-snmp net-snmp-utils

3. Configure o snmpd

Conforme detalhado na documentação do Caché, em sistemas Linux, a tarefa mais importante é verificar se o agente mestre SNMP no sistema é compatível com o protocolo Agent Extensibility (AgentX) (o Caché é executado como um subagente) e se o mestre está ativo e escutando conexões na porta TCP padrão do AgentX, 705.

Foi aqui que encontrei problemas. Cometi alguns erros básicos no arquivo snmp.conf que impediram o subagente SNMP do Caché de se comunicar com o agente mestre do sistema operacional. O seguinte arquivo de exemplo /etc/snmp/snmp.conf foi configurado para iniciar o AgentX e fornecer acesso aos MIBs SNMP do Caché e do Ensemble.

Observe que você terá que confirmar se a seguinte configuração está em conformidade com as políticas de segurança da sua organização.

No mínimo, as seguintes linhas devem ser editadas para refletir a configuração do seu sistema.

Por exemplo, altere:

syslocation  "System_Location"

para

syslocation  "Primary Server Room"

Edite também pelo menos as seguintes duas linhas:

syscontact  "Your Name"
trapsink  Caché_database_server_name_or_ip_address public 	

Edite ou substitua o arquivo /etc/snmp/snmp.conf existente para corresponder ao seguinte::


###############################################################################
#
# snmpd.conf:
#   Um arquivo de configuração de exemplo para configurar o agente NET-SNMP com o 
    #   Caché.
#
#   Isto foi usado com sucesso no Red Hat Enterprise Linux e executando
#   o daemon snmpd em primeiro plano com o seguinte comando:
#
#	/usr/sbin/snmpd -f -L -x TCP:localhost:705 -c./snmpd.conf
#
#  Você pode querer/precisar alterar algumas das informações, especialmente o
#   endereço IP do receptor de traps se você espera receber traps. Eu também vi
#   um caso (no AIX) onde tivemos que usar a opção "-C" na linha de comando snmpd,
#  para garantir que estávamos obtendo o arquivo snmpd.conf correto.
#
###############################################################################

###########################################################################
# SEÇÃO: Configuração de Informações do Sistema
#
#   Esta seção define algumas das informações relatadas no
#   grupo mib "system" na árvore mibII.

# syslocation: A localização [tipicamente física] do sistema.
#   Observe que definir este valor aqui significa que ao tentar
#   executar uma operação snmp SET na variável sysLocation.0, o agente
#   etornará o código de erro "notWritable". Ou seja, incluir
#   este token no arquivo snmpd.conf desativará o acesso de gravação à
#   variável.
#   argumentos:  string_de_localização

syslocation  "Localização do Sistema"

# syscontact: As informações de contato do administrador
#   Observe que definir este valor aqui significa que ao tentar
#   executar uma operação snmp SET na variável sysContact.0, o agente
#   retornará o código de erro "notWritable". Ou seja, incluir
#   este token no arquivo snmpd.conf desativará o acesso de gravação à
#  variável.
#   argumentos:  string_de_contato

syscontact  "Seu Nome"

# sysservices: O valor adequado para o objeto sysServices.
#   argumentos:  número_sysservices

sysservices 76

###########################################################################
# SEÇÃO: Modo de Operação do Agente
#
#   Esta seção define como o agente operará quando estiver em execução.
#   

# master: O agente deve operar como um agente mestre ou não.
#   Atualmente, o único tipo de agente mestre suportado para este token
#   é "agentx".
#   
#   argumentos: (on|yes|agentx|all|off|no)

master agentx
agentXSocket tcp:localhost:705

###########################################################################
#  SEÇÃO: Destinos de Trap
#
#   Aqui definimos para quem o agente enviará traps.

# trapsink: Um receptor de traps SNMPv1
#   argumentos: host [community] [portnum]

trapsink  Caché_database_server_name_or_ip_address public 	

###############################################################################
# Controle de Acesso
###############################################################################

# Como fornecido, o daemon snmpd responderá apenas a consultas no
# grupo mib do sistema até que este arquivo seja substituído ou modificado
# para fins de segurança. Exemplos de como aumentar o nível de acesso
# são mostrados abaixo.
#
# De longe, a pergunta mais comum que recebo sobre o agente é "por que ele
# não funciona?", quando na verdade deveria ser "como configuro o agente
# para me permitir acessá-lo?"
#
# Por padrão, o agente responde à comunidade "public" para acesso somente
# leitura, se executado diretamente, sem nenhum arquivo de configuração
# no lugar. Os exemplos a seguir mostram outras maneiras de configurar
# o agente para que você possa alterar os nomes da comunidade e conceder
# a si mesmo acesso de gravação à árvore mib também.
#
# Para mais informações, leia o FAQ, bem como a página de manual
# snmpd.conf(5).
#
####
# Primeiro, mapeie o nome da comunidade "public" para um "nome de segurança"

#       sec.name  source          community
com2sec notConfigUser  default       public

####
# Segundo, mapeie o nome de segurança para um nome de grupo:

#       groupName      securityModel securityName
group   notConfigGroup v1           notConfigUser
group   notConfigGroup v2c           notConfigUser

####
# Terceiro, crie uma visualização para que o grupo tenha direitos de acesso:

# Faça com que pelo menos o snmpwalk -v 1 localhost -c public system volte a ser rápido.
#       name           incl/excl     subtree         mask(optional)
# acesso ao subconjunto 'internet' 
view    systemview    included   .1.3.6.1

# Acesso aos MIBs do Cache Caché e Ensemble 
view    systemview    included   .1.3.6.1.4.1.16563.1
view    systemview    included   .1.3.6.1.4.1.16563.2
####
# Finalmente, conceda ao grupo acesso somente leitura à visualização systemview.	
#       group          context sec.model sec.level prefix read   write  notif
access  notConfigGroup ""      any       noauth    exact  systemview none none

Após editar o arquivo /etc/snmp/snmp.conf, reinicie o daemon snmpd.

service snmpd restart

Verifique o status do snmpd, observe que o AgentX foi iniciado, veja a linha de status: Ativando o suporte mestre AgentX.


h-4.2# service snmpd restart
Redirecting to /bin/systemctl restart  snmpd.service
sh-4.2# service snmpd status
Redirecting to /bin/systemctl status  snmpd.service
● snmpd.service - Simple Network Management Protocol (SNMP) Daemon.
   Loaded: loaded (/usr/lib/systemd/system/snmpd.service; disabled; vendor preset: disabled)
   Active: active (running) since Wed 2016-04-27 00:31:36 EDT; 7s ago
 Main PID: 27820 (snmpd)
   CGroup: /system.slice/snmpd.service
		   └─27820 /usr/sbin/snmpd -LS0-6d -f

Apr 27 00:31:36 vsan-tc-db2.iscinternal.com systemd[1]: Starting Simple Network Management Protocol (SNMP) Daemon....
Apr 27 00:31:36 vsan-tc-db2.iscinternal.com snmpd[27820]: Turning on AgentX master support.
Apr 27 00:31:36 vsan-tc-db2.iscinternal.com snmpd[27820]: NET-SNMP version 5.7.2
Apr 27 00:31:36 vsan-tc-db2.iscinternal.com systemd[1]: Started Simple Network Management Protocol (SNMP) Daemon..
sh-4.2# 

Após reiniciar o snmpd, você deve reiniciar o subagente SNMP do Caché usando a rotina ^SNMP:

%SYS>do stop^SNMP()

%SYS>do start^SNMP(705,20)

O daemon snmpd do sistema operacional e o subagente Caché agora devem estar em execução e acessíveis.

4. Testando o acesso MIB

O acesso MIB pode ser verificado a partir da linha de comando com os seguintes comandos. snmpget retorna um único valor:

snmpget -mAll -v 2c -c public vsan-tc-db2 .1.3.6.1.4.1.16563.1.1.1.1.5.5.72.50.48.49.53

SNMPv2-SMI::enterprises.16563.1.1.1.1.5.5.72.50.48.49.53 = STRING: "Cache for UNIX (Red Hat Enterprise Linux for x86-64) 2015.2.1 (Build 705U) Mon Aug 31 2015 16:53:38 EDT"

E snmpwalk irá 'percorrer' a árvore ou ramo MIB::

snmpwalk -m ALL -v 2c -c public vsan-tc-db2 .1.3.6.1.4.1.16563.1.1.1.1

SNMPv2-SMI::enterprises.16563.1.1.1.1.2.5.72.50.48.49.53 = STRING: "H2015"
SNMPv2-SMI::enterprises.16563.1.1.1.1.3.5.72.50.48.49.53 = STRING: "/db/trak/hs2015/cache.cpf"
SNMPv2-SMI::enterprises.16563.1.1.1.1.4.5.72.50.48.49.53 = STRING: "/db/trak/hs2015/mgr/"
etc
etc

Existem também vários clientes Windows e *nix disponíveis para visualizar dados do sistema. Eu uso o iReasoning MIB Browser gratuito. Você precisará carregar o arquivo ISC-CACHE.MIB no cliente para que ele reconheça a estrutura do MIB.

A imagem a seguir mostra o iReasoning MIB Browser no OSX.

free iReasoning MIB Browser

Incluindo em Ferramentas de Monitoramento

É aqui que podem haver grandes diferenças na implementação. A escolha da ferramenta de monitoramento ou análise fica a seu critério.

Por favor, deixe comentários na postagem detalhando as ferramentas e o valor que você obtém delas para monitorar e gerenciar seus sistemas. Isso será de grande ajuda para outros membros da comunidade.

Abaixo está uma captura de tela do popular PRTG Network Monitor mostrando métricas do Caché. Os passos para incluir métricas do Caché no PRTG são semelhantes aos de outras ferramentas.

PRTG Monitoring tool

Fluxo de trabalho de exemplo - adicionando o MIB do Caché à ferramenta de monitoramento.

Passo 1.

Certifique-se de que você pode se conectar aos MIBs do sistema operacional. Uma dica é solucionar problemas com o sistema operacional, não com o Caché. É muito provável que as ferramentas de monitoramento já conheçam e estejam pré-configuradas para MIBs comuns de sistemas operacionais, então a ajuda de fornecedores ou outros usuários pode ser mais fácil.

Dependendo da ferramenta de monitoramento que você escolher, pode ser necessário adicionar um 'módulo' ou 'aplicativo' SNMP, que geralmente são gratuitos ou de código aberto. Achei as instruções do fornecedor bastante diretas para esta etapa.

Uma vez que você esteja monitorando as métricas do sistema operacional, é hora de adicionar o Caché.

Passo 2.

Importe os arquivos ISC-CACHE.mib eISC-ENSEMBLE.mibpara a ferramenta para que ela reconheça a estrutura do MIB.

Os passos aqui irão variar; por exemplo, o PRTG possui um utilitário 'Importador de MIB'. Os passos básicos são abrir o arquivo de texto ISC-CACHE.mib na ferramenta e importá-lo para o formato interno da ferramenta. Por exemplo, o Splunk usa um formato Python, etc.

Nota:_ Descobri que a ferramenta PRTG expirava o tempo limite se eu tentasse adicionar um sensor com todos os ramos do MIB do Caché. Presumo que ele estava percorrendo toda a árvore e expirou o tempo limite para algumas métricas como listas de processos. Não gastei tempo solucionando esse problema, em vez disso, contornei o problema importando apenas o ramo de desempenho (cachePerfTab) do ISC-CACHE.mib.

Uma vez importado/convertido, o MIB pode ser reutilizado para coletar dados de outros servidores em sua rede. O gráfico acima mostra o PRTG usando o sensor Sensor Factory para combinar vários sensores em um único gráfico.

Resumo

Existem muitas ferramentas de monitoramento, alerta e algumas ferramentas de análise muito inteligentes disponíveis, algumas gratuitas, outras com licenças para suporte e muitas funcionalidades variadas.

Você deve monitorar seu sistema e entender qual atividade é normal e qual atividade foge do normal e deve ser investigada. SNMP é uma maneira simples de expor métricas do Caché e do Ensemble.

0
0 40
Artigo Heloisa Paiva · Fev. 17, 2025 6m read

Monitorar sua implantação do IRIS é crucial. Com a descontinuação do System Alert and Monitoring (SAM), uma solução moderna e escalável é necessária para obter insights em tempo real, detecção precoce de problemas e eficiência operacional. Este guia aborda a configuração do Prometheus e Grafana no Kubernetes para monitorar o InterSystems IRIS de forma eficaz.

Este guia pressupõe que você já tenha um cluster IRIS implantado usando o InterSystems Kubernetes Operator (IKO), que simplifica a implantação, integração e gerenciamento.

 

Por que Prometheus e Grafana?

0
0 64
Artigo Heloisa Paiva · Out. 4, 2024 4m read

Então, se você está acompanhando do post anterior ou entrando agora, vamos passar para o mundo dos aplicativos eBPF e dar uma olhada no Parca, que se baseia em nossa breve investigação de gargalos de desempenho usando eBPF, mas coloca um aplicativo incrível no topo do seu cluster para monitorar todas as suas cargas de trabalho iris, continuamente, em todo o cluster!

Perfilamento Contínuo com Parca, Cargas de Trabalho IRIS em Todo o Cluster

0
0 37
Artigo Heloisa Paiva · Out. 2, 2024 15m read

Eu estive na Cloud Native Security Con em Seattle com total intenção de entrar no dia de OTEL, então lendo o assunto de segurança aplicada a fluxos de trabalho Cloud Native nos dias seguintes até CTF como um exercício profissional. Isso foi felizmente finalizado por um novo entendimento de eBPF, que tem minhas telas, carreira, fluxos de trabalho e atitude com muita necessidade de uma melhoria com novas abordagens para resolver problemas de fluxo de trabalho.

Então, consegui chegar à festa do eBPF e desde então tenho participado de clínica após clínica sobre o assunto. Aqui, gostaria de "desempacotar" o eBPF como uma solução técnica, mapeada diretamente para o que fazemos na prática (mesmo que esteja um pouco fora), e passar pelo eBPF através da minha experimentação em suporte a cargas de trabalho InterSystems IRIS, particularmente no Kubernetes, mas não necessariamente vazio em cargas de trabalho autônomas.

Passos eBee com eBPF e fluxos de trabalho InterSystems IRIS

0
0 31
Artigo Julio Esquerdo · Maio 24, 2024 5m read

Olá,

Neste artigo vamos ver o uso do Prometheus (prometheus.io) para coletar métricas no Iris, de forma a monitorarmos o ambiente.

O link https://cloud.google.com/discover/what-is-prometheus?hl=pt-br apresenta uma descrição bem completa do Prometheus.

O Iris conta com uma api que disponibiliza uma série de informações do ambiente. A documentação completa da api pode ser encontrada no endereço https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=GCM_rest

Uma simples chamada a api já nos mostra as informações disponíveis:

0
0 141
Artigo Rochael Ribeiro · Abr. 12, 2024 1104m read

O Enterprise Monitor é um componente do Ensemble e pode ajudar as organizações a monitorar várias produções executadas em diferentes namespaces na mesma instância ou em namespaces executados em várias instâncias.

A documentação pode ser encontrada em:

http://docs.intersystems.com/ens20161/csp/docbook/DocBook.UI.Page.cls?KEY=EMONITOR_all#EMONITOR_enterprise

No Ensemble 2016.1, foram realizadas mudanças para esse utilitário funcionar com ambientes do HealthShare.

Este artigo mostrará o seguinte:

  • Como configurar o Enterprise Monitor para sites do HealthShare
  • Alguns recursos do Enterprise Monitor
  • Alguns recursos do Enterprise Message Viewer

Para este artigo, usei a seguinte versão do HealthShare:

Cache para Windows (x86-64) 2016.1 (Build 656U) Sex 11 Mar 2016 17:42:42 EST [Módulos do HealthShare:Core:14.02.2415 + Linkage Engine:14.02.2415 + Patient Index:14.02.2415 + Clinical Viewer:14.02.2415 + Active Analytics:14.02.2415] __

Configurar o Enterprise Monitor

Criar um novo namespace

O Enterprise Monitor é executado no seu próprio namespace e pode estar localizado em uma instância existente ou separada.  Neste artigo, ele será executado na mesma instância.

Para criar um namespace:

  • Acesse o Portal de Gerenciamento de Sistemas -> System Administration (Administração do sistema) -> Configuration (Configuração) -> System Configuration (Configuração do sistema) -> Namespaces
  • Clique no botão "Create New Namespace" (Criar novo namespace)

Neste exemplo, criei um namespace HSMONITOR.  Também criei um banco de dados chamado HSMONITOR

Captura de tela de como criar um namespace:

Editar o aplicativo da Web

Para instâncias do HealthShare, o aplicativo da Web define, por padrão, o "Session Cookie Path" (Caminho do cookie da sessão) como "/csp/healthshare/".   Se o namespace do Enterprise Monitor estiver em uma instância com outros namespaces do HealthShare, mude o "Session Cookie Path" do namespace do Enterprise Monitor para "/csp/healthshare/[namespace]/".

Para mudar o aplicativo da Web:

  • Acesse o Portal de Gerenciamento de Sistema -> System Administration -> Security (Segurança) -> Applications (Aplicativos) -> Web Applications (Aplicativos da Web)
  • Selecione o aplicativo da Web que foi criado para seu namespace do Enterprise Monitor. No meu caso, é "/csp/healthshare/hsmonitor".
  • Selecione o menu suspenso de "Session Cookie Path" e altere para "/csp/healthshare/[namespace]/". No meu caso, selecionei "/csp/healthshare/hsmonitor/".

Captura de tela de como alterar o aplicativo da Web:

Adicionar uma credencial

O Enterprise Monitor usa serviços da Web para se comunicar com diversos sistemas, então ele precisa de um nome de usuário/senha para validar a comunicação. O Ensemble consegue fazer isso usando credenciais. Todos os namespaces do HealthShare usam credenciais com o nome de usuário "HS_Services"

Vamos adicionar "HS_Services" às credenciais do namespace do Ensemble que criamos para o Enterprise Monitor.

Etapas para criar uma credencial:

  • Acesse o Portal de Gerenciamento de Sistemas ->  Ensemble
  • Selecione o namespace do Enterprise Monitor, se solicitado, ou mude o namespace usando o link "switch" (trocar) no topo do Portal de Gerenciamento de Sistemas.
  • Acesse Configure (Configurar) -> Credentials (Credenciais)
  • Clique no botão "New" (Novas)
  • Defina o ID como "HS_Services"
  • Defina "UserName" (Nome de usuário) como "HS_Services"
  • Defina "Password" como a senha que o "HS_Services" usa para os outros namespaces do HealthShare.

Captura de tela de como adicionar credenciais:

Criar uma produção

Em seguida, criamos uma produção que usa o serviço empresarial "Ens.Enterprise.MonitorService".  Essa é a produção que será executada no namespace do Enterprise Monitor que configuramos.

Confira a seguir a produção que criei.  Observe que ela estende "Ens.Enterprise.Production" e inclui um item de serviço empresarial, que foi adicionado (Ens.Enterprise.MonitorService).

Class HSMONITOR.MonitorProduction Extends Ens.Enterprise.Production
{
XData ProductionDefinition
{
<Production Name="HSMONITOR.MonitorProduction">
    <ActorPoolSize>2</ActorPoolSize>
    <Item Name="Ens.Enterprise.MonitorService" ClassName="Ens.Enterprise.MonitorService" PoolSize="1" />
</Production>
}

}

Depois disso, você pode iniciar a produção no namespace do Enterprise Monitor que você criou.  Nesse exemplo, iniciei o HSMONITOR.MonitorProduction no meu namespace HSMONITOR.

Adicionar um sistema empresarial

Agora que a produção está sendo executada, podemos adicionar os sistemas empresariais que queremos monitorar.

Para criar um novo sistema empresarial:

  • Acesse o Portal de Gerenciamento de Sistemas -> Ensemble
  • Confira se você está no namespace do Enterprise Monitor
  • Acesse Configure -> Enterprise Systems (Sistemas empresariais)
  • Clique no novo botão "New Connection" (Nova conexão)

Captura de tela dos sistemas empresariais:

Para adicionar uma nova conexão:

  • Insira o nome
  • Insira o endereço IP da Web
  • Insira o namespace
  • Insira o caminho para o serviço de aplicativo da Web
  • Insira as credenciais Soap
  • Clique no botão "Save" (Salvar).

Captura de tela de como adicionar uma conexão a HSREGISTRY:

Você pode adicionar vários sistemas empresariais para refletir seus ambientes do HealthShare.  É possível adicionar gateways de borda, gateways de acesso, outros componentes do HealthShare, como Personal Community, Patient Index, Health Insight, etc.

A maioria das informações do HealthShare está localizada no registro de serviços.

Coloquei meu namespace do Enterprise Monitor na mesma instância que o HSREGISTRY.

Escrevi e executei o seguinte código no meu namespace HSMONITOR para criar sistemas empresariais de forma automática com base nas informações localizadas no registro de serviços.

Código de amostra:

ClassMethod BuildEM()
{
                set tSaveNamespace = $namespace
                zn "HSREGISTRY"             
           
                set sql="select EndPoint,Name,Info from HS_Registry_Service.SOAP"
                set statement = ##class(%SQL.Statement).%New()
                set tSC = statement.%Prepare(sql)
                quit:$$$ISERR(tSC)
                set result = statement.%Execute()
                while result.%Next() {
                                set tEndPoint = result.EndPoint
                                set tName = result.Name
                                set tInfo = result.Info
                                If tName = "HSREGISTRY" set tName = ":"_tName
                                If tName = "HSPI" set tName = ":"_tName
                                If $p(tName,":",2) = "WebServices" set tName = ":"_tName
                                If tName = "HSCommunity.PIXv3.Consumer" set tName = ":HSCOMMUNITY"
                                Continue:$p(tName,":",2)=""
                                set tMCName = $p(tName,":",2)
                                set tMCNamespace = $p(tEndPoint,"/",6)
                                set tMCWebIP = tInfo
                                set tMCHomePath = "/"_$p(tEndPoint,"/",4,6)_"/"
                                set tMCServicePath = "/"_$p(tEndPoint,"/",4,7)_"/"
                                set aMC(tMCName)=$lb(tMCNamespace,tMCWebIP,tMCHomePath,tMCServicePath)
                }
                zn tSaveNamespace
                ///Now we have an array of namespaces, create Monitor entries
                set tName = ""
                do {
                  set tName=$O(aMC(tName))
                  if tName '="" {
                                set tMonitorClient = ##class(Ens.Enterprise.MonitorClient).%New()
                                set tMonitorClient.Name=tName 
                                set tMonitorClient.WebIPAddress=$list(aMC(tName),2) ;IP/Port
                                set tMonitorClient.Namespace=$list(aMC(tName),1) ;NameSpace
                                set tMonitorClient.HomePage="%25CSP.Portal.Home.zen"
                                set tMonitorClient.HomePath=$list(aMC(tName),3) ;"/csp/healthshare/[namespace]/"
                                set tMonitorClient.QueueThreshold=""
                                set tMonitorClient.ServicePath=$list(aMC(tName),4) ;"/csp/healthshare/[namespace]/services/"
                                set tMonitorClient.SOAPCredentials="HS_Services"
                                set tMonitorClient.SSLCheckServerIdentity="1"
                                set tMonitorClient.SSLConfig=""
                                set tMonitorClient.Version="2016.1.1.108.1."
                                set tSC=tMonitorClient.%Save()
                                w !,tName,": ",$system.Status.DisplayError(tSC)
                  }
                } while tName '= ""
                quit
}

Enterprise Monitor

Agora que temos entradas no sistema empresarial, você verá uma nova opção de menu no namespace do Enterprise Monitor do Ensemble.  Essa nova opção de menu será "Enterprise Monitor".

Captura de tela da nova opção de menu:

Ao selecionar "Enterprise Monitor", vemos o seguinte:

Agora podemos ver em um único local quais produções do HealthShare estão "Running" (em execução) ou "Stopped" (interrompidas), com links para as configurações das que estiverem em execução.

Ao selecionar uma linha, é possível ver os detalhes de cada ambiente.  Confira este exemplo:

Essa tela mostra detalhes sobre:

  • Conexões de entrada
  • Conexões de saída
  • Filas
  • Registro de eventos
  • Gráfico de atividades
  • Lista de mensagens do Ensemble

Você também pode adicionar métricas personalizadas.

Confira mais informações sobre o monitor de produções:

http://docs.intersystems.com/ens20161/csp/docbook/DocBook.UI.Page.cls?KEY=EMONITOR_production

Enterprise Message Viewer

Com o Enterprise Monitor configurado, você também pode conferir o Enterprise Message Viewer.

Neste exemplo, acesse "Patient Search" (Pesquisa de pacientes) no HSACCESS, faça uma consulta, selecione um paciente e veja as informações mostradas no Clinical Viewer.

Ao acessar o Enterprise Message Viewer, é possível ver todos os sistemas chamados e as informações que foram usadas para realizar essa ação do Clinical Viewer.

Agora há um único lugar para ver como as mensagens estão fluindo em todos os sistemas/namespaces no ambiente do HealthShare.

OBSERVAÇÃO:  esse utilitário Enterprise Message Viewer contém somente informações básicas do cabeçalho de mensagens do Ensemble.  Ele fornece links para os detalhes específicos da sessão e direciona você aos detalhes e rastreamentos da mensagem do Ensemble.

Conclusão

O Enterprise Monitor e o Enterprise Message Viewer são ferramentas novas no Ensemble que ajudarão os clientes do HealthShare a gerenciar os ambientes e ver fluxos de trabalho no HealthShare.

Enterprise Monitor:

  • Local único para ver quais ambientes estão em execução e quais foram interrompidos
  • Links para todas as configurações de produção no ambiente do HealthShare
  • Consulta dos detalhes de cada produção, incluindo
    • Conexões de entrada
    • Conexões de saída
    • Filas
    • Registro de eventos
    • Gráfico de atividades
    • Mensagens

Enterprise Message Viewer:

  • Visualização única de todas as mensagens no ambiente do HealthShare
0
0 53
Artigo Danusa Calixto · Abr. 4, 2024 12m read

Olá, Desenvolvedores!

Hoje quero falar sobre um assunto que já me deu trabalho. Tenho certeza de que isso deve ter acontecido com muitos de vocês (o chamado "gargalo"). Como esse é um tema amplo, este artigo focará apenas em identificar solicitações HTTP recebidas que podem estar causando problemas de lentidão. Também disponibilizarei uma pequena ferramenta que desenvolvi para ajudar a identificá-las.

Nosso software está cada vez mais complexo, processando um grande número de solicitações de diferentes origens, seja aplicativos de front-end ou back-end de terceiros. Para garantir um desempenho ideal, é fundamental ter um sistema de registro capaz de obter algumas medições importantes, como tempo de resposta, número de referências globais e número de linhas de código executadas para cada resposta HTTP. Como parte do meu trabalho, participo do desenvolvimento de software EMR e da análise de incidentes.  Como a carga do usuário vem principalmente de solicitações HTTP (API REST ou aplicativo CSP), a necessidade desse tipo de medição quando ocorrem problemas generalizados de lentidão se tornou óbvia.

Medição de tempo de resposta

Um dos elementos mais relevantes para avaliar o desempenho de um aplicativo é o tempo de resposta. Cada solicitação precisa ser respondida dentro de um prazo razoável para fornecer uma experiência satisfatória ao usuário. Por isso que, ao registrar o tempo de resposta de cada solicitação, um sistema de registro ajuda a identificar o desempenho ruim. Também podemos usar essas informações para identificar quais APIs ou CSPs são mais lentos a fim de otimizá-los e aumentar a execução geral do aplicativo​.

Número de referências globais

Embora o tempo de resposta seja uma característica essencial, também não devemos negligenciar o número de referências globais. Devemos lembrar que o acesso ao disco também costuma ser uma operação cara em termos de tempo de execução. No entanto, a eficiência do cache IRIS pode mascarar esse problema. Quero dizer com isso que, se muitas referências globais em cache forem acessadas simultaneamente, o tempo de resposta será excelente. Ainda assim, o desempenho cai consideravelmente assim que os dados acessados vêm de fora do cache. Em outras palavras, em um sistema onde são feitas várias solicitações ao mesmo tempo, o uso excessivo do acesso ao disco pode causar uma lentidão considerável. Um sistema de registro que mede referências de acesso global para cada solicitação também nos permite detectar solicitações HTTP que solicitam recursos em excesso. Ao identificar problemas desse tipo, os desenvolvedores podem fazer alterações para minimizar esse acesso (adicionando índices, otimizando consultas SQL, mudando a lógica etc.)

Número de linhas de código executadas

Contar o número de linhas de código executadas para cada solicitação nos oferece uma medida da complexidade e magnitude das operações realizadas. Essa medição nos ajuda a identificar consultas que executam muitas linhas de código, o que pode indicar partes do código que precisam de otimização. Na maioria dos casos, o problema está no número de referências globais. Porém, caso uma parte complexa do código seja apenas a manipulação de dados de memória com pouco acesso ao banco de dados, essa medição permitirá destacá-la (por exemplo, se houver um problema com loops).

Detecção de anomalias

Um registro do sistema também pode ser usado para detectar anomalias no desempenho da consulta de resposta. Ao registrar essas medições, é possível identificar solicitações fora do comum. Por exemplo, se uma consulta que costuma ser executada rapidamente de repente começa a demorar mais ou a acessar o disco em excesso, pode haver um problema que exige atenção imediata (como um maior tempo de resposta após a atualização de um aplicativo). Lembre-se de que a detecção precoce de anomalias nos ajuda a resolver problemas de desempenho rapidamente e garante uma boa experiência do usuário.

Pacote web-timing-logger

Recentemente, desenvolvi uma pequena ferramenta para a comunidade que nos permite registrar todas as solicitações HTTP recebidas. Se você tiver interesse, ela está disponível no Open Exchange. Essa ferramenta registra especialmente as principais métricas discutidas neste artigo: número de linhas de código executadas, número de referências globais e tempo de resposta. Ela também registra algumas informações sobre o autor da chamada que podem ser úteis para depuração:

  • Data e hora.
  • O usuário conectado.
  • Endereço IP do autor da chamada.
  • URL.
  • Namespace de execução.
  • Web app.
  • Nome da página (se aplicável).
  • URL sem parâmetros.

 

Além disso, também oferece a capacidade de integrar métricas personalizadas com SAM ("/api/monitor"), que permite incorporá-las no Prometheus e criar um painel de controle com o Grafana.
Há uma série de dados por web app, página ou rota (se for um aplicativo REST) ​​agregado por dia e quarto de hora:

  • Total de acessos: número de solicitações recebidas.
  • Tempo total: tempo de resposta cumulativa para todas as solicitações.
  • Tempo máximo: tempo de resposta mais lento.
  • Tempo média: tempo médio de resposta.

As mesmas métricas também estão disponíveis para referências globais e linhas de código executadas.

                                                                                                   Fichier:Prometheus software logo.svg — Wikipédia

Abaixo você pode ver um exemplo com as métricas ativadas nos web apps "/api/monitor/" e "/csp/sys/exp/":

webmeasure_average_gloref{id="/api/monitor/"} 903.5227272727272727
webmeasure_average_gloref{id="/api/monitor/metrics"} 903.5227272727272727
webmeasure_average_gloref{id="/csp/sys/exp/"} 1853.6875
webmeasure_average_gloref{id="/csp/sys/exp/%CSP.Broker.cls"} 1242.933333333333333
webmeasure_average_gloref{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 11015
webmeasure_average_gloref_current_quarter{id="/api/monitor/"} 903.5227272727272727
webmeasure_average_gloref_current_quarter{id="/api/monitor/metrics"} 903.5227272727272727
webmeasure_average_gloref_current_quarter{id="/csp/sys/exp/"} 1853.6875
webmeasure_average_gloref_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 1242.933333333333333
webmeasure_average_gloref_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 11015
webmeasure_average_lines{id="/api/monitor/"} 29365.5
webmeasure_average_lines{id="/api/monitor/metrics"} 29365.5
webmeasure_average_lines{id="/csp/sys/exp/"} 19415.5
webmeasure_average_lines{id="/csp/sys/exp/%CSP.Broker.cls"} 11570.73333333333333
webmeasure_average_lines{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 137087
webmeasure_average_lines_current_quarter{id="/api/monitor/"} 29365.5
webmeasure_average_lines_current_quarter{id="/api/monitor/metrics"} 29365.5
webmeasure_average_lines_current_quarter{id="/csp/sys/exp/"} 19415.5
webmeasure_average_lines_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 11570.73333333333333
webmeasure_average_lines_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 137087
webmeasure_average_timing_in_ms{id="/api/monitor/"} 27.27256818181818182
webmeasure_average_timing_in_ms{id="/api/monitor/metrics"} 27.27256818181818182
webmeasure_average_timing_in_ms{id="/csp/sys/exp/"} 16.6
webmeasure_average_timing_in_ms{id="/csp/sys/exp/%CSP.Broker.cls"} 9.94633333333333333
webmeasure_average_timing_in_ms{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 116.405
webmeasure_average_timing_in_ms_current_quarter{id="/api/monitor/"} 27.27256818181818182
webmeasure_average_timing_in_ms_current_quarter{id="/api/monitor/metrics"} 27.27256818181818182
webmeasure_average_timing_in_ms_current_quarter{id="/csp/sys/exp/"} 16.6
webmeasure_average_timing_in_ms_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 9.94633333333333333
webmeasure_average_timing_in_ms_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 116.405
webmeasure_max_lines{id="/api/monitor/"} 29498
webmeasure_max_lines{id="/api/monitor/metrics"} 29498
webmeasure_max_lines{id="/csp/sys/exp/"} 137087
webmeasure_max_lines{id="/csp/sys/exp/%CSP.Broker.cls"} 45208
webmeasure_max_lines{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 137087
webmeasure_max_lines_current_quarter{id="/api/monitor/"} 29498
webmeasure_max_lines_current_quarter{id="/api/monitor/metrics"} 29498
webmeasure_max_lines_current_quarter{id="/csp/sys/exp/"} 137087
webmeasure_max_lines_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 45208
webmeasure_max_lines_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 137087
webmeasure_max_timing{id="/api/monitor/"} 40.783
webmeasure_max_timing{id="/api/monitor/metrics"} 40.783
webmeasure_max_timing{id="/csp/sys/exp/"} 116.405
webmeasure_max_timing{id="/csp/sys/exp/%CSP.Broker.cls"} 66.458
webmeasure_max_timing{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 116.405
webmeasure_max_timing_current_quarter{id="/api/monitor/"} 40.783
webmeasure_max_timing_current_quarter{id="/api/monitor/metrics"} 40.783
webmeasure_max_timing_current_quarter{id="/csp/sys/exp/"} 116.405
webmeasure_max_timing_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 66.458
webmeasure_max_timing_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 116.405
webmeasure_total_gloref{id="/api/monitor/"} 39755
webmeasure_total_gloref{id="/api/monitor/metrics"} 39755
webmeasure_total_gloref{id="/csp/sys/exp/"} 29659
webmeasure_total_gloref{id="/csp/sys/exp/%CSP.Broker.cls"} 18644
webmeasure_total_gloref{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 11015
webmeasure_total_gloref_current_quarter{id="/api/monitor/"} 39755
webmeasure_total_gloref_current_quarter{id="/api/monitor/metrics"} 39755
webmeasure_total_gloref_current_quarter{id="/csp/sys/exp/"} 29659
webmeasure_total_gloref_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 18644
webmeasure_total_gloref_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 11015
webmeasure_total_hit{id="/api/monitor/"} 44
webmeasure_total_hit{id="/api/monitor/metrics"} 44
webmeasure_total_hit{id="/csp/sys/exp/"} 16
webmeasure_total_hit{id="/csp/sys/exp/%CSP.Broker.cls"} 15
webmeasure_total_hit{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 1
webmeasure_total_hit_current_quarter{id="/api/monitor/"} 44
webmeasure_total_hit_current_quarter{id="/api/monitor/metrics"} 44
webmeasure_total_hit_current_quarter{id="/csp/sys/exp/"} 16
webmeasure_total_hit_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 15
webmeasure_total_hit_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 1
webmeasure_total_lines{id="/api/monitor/"} 1292082
webmeasure_total_lines{id="/api/monitor/metrics"} 1292082
webmeasure_total_lines{id="/csp/sys/exp/"} 310648
webmeasure_total_lines{id="/csp/sys/exp/%CSP.Broker.cls"} 173561
webmeasure_total_lines{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 137087
webmeasure_total_lines_current_quarter{id="/api/monitor/"} 1292082
webmeasure_total_lines_current_quarter{id="/api/monitor/metrics"} 1292082
webmeasure_total_lines_current_quarter{id="/csp/sys/exp/"} 310648
webmeasure_total_lines_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 173561
webmeasure_total_lines_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 137087
webmeasure_total_timing_in_ms{id="/api/monitor/"} 1199.993
webmeasure_total_timing_in_ms{id="/api/monitor/metrics"} 1199.993
webmeasure_total_timing_in_ms{id="/csp/sys/exp/"} 265.6
webmeasure_total_timing_in_ms{id="/csp/sys/exp/%CSP.Broker.cls"} 149.195
webmeasure_total_timing_in_ms{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 116.405
webmeasure_total_timing_in_ms_current_quarter{id="/api/monitor/"} 1199.993
webmeasure_total_timing_in_ms_current_quarter{id="/api/monitor/metrics"} 1199.993
webmeasure_total_timing_in_ms_current_quarter{id="/csp/sys/exp/"} 265.6
webmeasure_total_timing_in_ms_current_quarter{id="/csp/sys/exp/%CSP.Broker.cls"} 149.195
webmeasure_total_timing_in_ms_current_quarter{id="/csp/sys/exp/%CSP.UI.Portal.SQL.Home.zen"} 116.405

Você deve ter notado que as métricas ilustradas acima são muito genéricas. Recomendo fortemente que você amplie e personalize suas métricas. É necessário para o monitoramento adequado dos aplicativos

Instalação usando ZPM

Se você deseja fazer uma instalação de teste e é usuário do Docker, recomendo que você revise esta seção para obter algumas informações práticas antes de passar para a próxima. O script de criação do contêiner configura o ambiente automaticamente.

A instalação é feita com o ZPM. Basta acessar o terminal IRIS e executar o seguinte:

zpm "install web-timing-logger”

Após a instalação, você precisa inicializar as configurações, então execute:

Do##class(dc.webtiming.Config).Initialize()

Por padrão, o log e as métricas de solicitações HTTP não estão ativos. Para ativá-los, siga as seguintes etapas:

Do##class(dc.webtiming.Config).SetLogEnabled(1)

Do##class(dc.webtiming.Config).SetMetricsEnabled(1)

Para SAM ("/api/monitor") expor métricas personalizadas, além de adicionar uma função ao web app /API/monitor, você deve registrar uma classe em SYS.Monitor.SAM.Config. Então, execute o seguinte comando:

Do##class(dc.webtiming.Config).ConfigureAPIMonitor()

Se você quiser usar esse utilitário em diversos web apps que são executados em diferentes namespaces, é fundamental mapear o pacote "dc.webtiming" e os globais "dc.webtiming*" em “%ALL”.  Para evitar fazer isso manualmente, use o método especificado abaixo:

Do##class(dc.webtiming.Config).AddToPercentAllNS()

Todas as ações mencionadas acima podem ser executadas em uma única linha com o próximo comando:

Do##class(dc.webtiming.Config).DefaultSetup()

Instalação usando Docker

O início com o Docker é clássico. Clone o repositório e inicie o contêiner:

git clone https://github.com/lscalese/iris-web-timing-logger.git
docker-compose up -d

Ativação em um web app

Agora que configuramos o sistema, ainda há um detalhe importante a ser configurado para que você possa registrar as medições. Para entender o que é preciso fazer, você deve saber como funciona o sistema.  Para acionar a medição e o registro, o web-timing-logger usa os eventos "OnStartRequest" e "OnEndRequest". Esses eventos são implementados na classe "dc.webtiming.CSPSessionEvents", que é uma subclasse de "%CSP.SessionEvents". Em seguida, cada web app precisa ser configurado com a classe de evento "dc.webtiming.CSPSessionEvents".

 

Se o seu web app já estiver usando outra classe de evento, não se preocupe! Basta adicionar as seguintes chamadas a essa classe:

No método OnStartRequest: 

Do##class(dc.webtiming.Events).OnStart()

e no método OnEndRequest:

Do##class(dc.webtiming.Events).OnEnd()

Isso adicionará a funcionalidade de medição e gravação às suas classes de evento existentes.

Faça essa configuração para todos os web apps que você deseja medir.

Se você tiver um sistema vazio e só quiser fazer alguns testes, use a configuração no web app /API/monitor. Como o acesso às métricas é estabelecido por uma chamada HTTP, elas também podem ser medidas para gerar logs.  Então, basta abrir seu navegador e acessar a página http://localhost:49165/api/monitor/metrics várias vezes (adapte com o número da sua porta). Você perceberá que as métricas "webmeasure" são alimentadas, e a tabela "dc_webtiming_log.Request" é preenchida com dados de solicitações HTTP:

SELECT *
FROM dc_webtiming_log.Request

Mesmo que Web-timing-logger facilite a identificação de pontos de entrada problemáticos em web apps, ele não oferece informações precisas sobre partes específicas do código que estão causando problemas.   Depois de identificar o ponto de entrada, você poderá usar outras ferramentas, como OEX ZProfile, desenvolvida por Dmitry Maslennikov. Ela pode realizar uma análise aprofundada do código que está sendo executado. Confira um artigo dedicado aqui.

Isso é tudo por hoje. É claro que poderíamos abordar outras coisas sobre o "web-timing-logger", como limpeza de logs, exemplo do painel de controle do Grafana ou até mesmo algumas consultas SQL interessantes. Espero que você tenha gostado do artigo e ele tenha dado ideias para o monitoramento dos seus aplicativos. Posso escrever uma continuação se você tiver interesse.

Até logo!

0
0 63
Anúncio Danusa Calixto · Mar. 4, 2024

Olá Desenvolvedores, 

Nossa primeira Mesa Redonda da Comunidade de Desenvolvedores de 2024 irá acontecer no dia 5 de Março de 2024 às 11 horas (BR-SP).

Palestras sobre tecnologia:

  1. Ferramentas de Testes Unitários de ObjectScript, Técnicas e Melhores Práticas - por @Timothy Leavitt , Development Manager, Application Services, InterSystems
  2. Capacidades de Monitoramento e Alertas do InterSystems IRIS - por @Mark Bolinsky , Principal Technology Architect, InterSystems. A apresentação de Mark foi remarcada para a mesa redonda de abril.

>> RVSP no desafio do Global Masters <<
[se você ainda não é membro do Global Masters, é só logar usando a sua credencial SSO InterSystems e clique neste link novamente]

 

1
0 54
InterSystems Oficial Angelo Bruno Braga · Nov. 10, 2022

A InterSystems tem o prazer de anunciar o lançamento do System Alerting & Monitoring (SAM) versão 2.0

O que é o SAM?

O SAM se conecta aos padrões utilizados nas  APIS de Monioramento e do Monitor de Logs do IRIS com ferramentas familiares padrão do setor, como Grafana e Prometheus, para criar uma solução básica de monitoramento e alerta para clusters IRIS.

Para saber mais sobre SAM, consulte o Guia de Alerta e Monitoramento do sistema.

 

O que há de novo no SAM 2.0?

As ferramentas padrão do setor nas quais o SAM se baseia foram todas atualizadas.

0
0 76
Anúncio Angelo Bruno Braga · Out. 24, 2022

Certifique-se em Administração de Sistema InterSystems IRIS!

Olá Comunidade,

Após o teste beta do novo exame de Certificação de Especialista em Administração de Sistemas InterSystems IRIS, a equipe de certificação dos Serviços de Aprendizagem InterSystems realizou a calibração e os ajustes necessários para liberá-lo para nossa comunidade. Já está pronto para compra e agendamento no catálogo de exames de certificação da InterSystems. Os candidatos em potencial podem analisar os tópicos do exame e as questões práticas para ajudar a orientá-los quanto às abordagens e conteúdo das questões do exame. A aprovação no exame permite que você reivindique um selo de certificação eletrônico que pode ser incorporado a contas de mídia social, como o Linkedin..  

0
0 73
InterSystems Oficial Angelo Bruno Braga · Maio 2, 2022

A InterSystems está grata em anunciar o lançamento da versão 1.1 do System Alerting & Monitoring (SAM) version 1.1.

O que é o SAM?

O SAM adiciona à API de Monitoramento baseada em padrões e ao Monitor de Log  ferramentas padrão de mercado como o Grafana e o  Prometheus para criar uma solução básica de monitoramento e geração de alertas para clusters IRIS.

Para mai informações sobre o SAM, veja o Guia de Monitoramento e Alerta do Sistema.

O que tem de novo no SAM 1.1?

0
0 133
Artigo Angelo Bruno Braga · Abr. 28, 2022 4m read

De tempos em tempos recebemos a pergunta do título deste artigo no suporte, em situações onde algo ou alguém está utilizando mais licenças do que o esperado, e precisamos então identificar o quê.

Temos dois cenários. O primeiro cenário ocorre quando percebemos que as licenças acabaram através de uma aplicação que não funciona ou quando tentamos conectar ao terminal e recebemos a "graciosa" mensagem: <LICENSE LIMIT EXCEEDED>  

0
0 106
Pergunta Jonathan Rafael Mathes · Ago. 30, 2021

Boa tarde pessoal.

Alguém já conseguiu fazer algum monitoramento em cima do cache?

Estamos fazendo um estudo para adequação do numero de licenças e queria fazer um gráfico com as licenças usadas. Pensei em fazer isso pelo zabbix.

9
0 263
Pergunta Jonathan Rafael Mathes · Ago. 30, 2021

Boa tarde pessoal.

Alguém já conseguiu fazer algum monitoramento em cima do cache?

Estamos fazendo um estudo para adequação do numero de licenças e queria fazer um gráfico com as licenças usadas. Pensei em fazer isso pelo zabbix.

0
0 30
Artigo Guilherme Koerber · Mar. 31, 2021 4m read

Houve alguns artigos muito úteis na comunidade que mostram como usar o Grafana com IRIS (ou Cache/Ensemble) usando um banco de dados intermediário.

Mas eu queria chegar diretamente às estruturas IRIS. Em particular, eu queria acessar os dados do monitor de histórico do cache que podem ser acessados por SQL, conforme descrito aqui

https://community.intersystems.com/post/apm-using-cach%C3%A9-history-mo…

E não queria nada entre mim e os dados.

0
0 235
Artigo David Loveluck · Dez. 9, 2020 26m read

Desde o Caché 2017, o mecanismo SQL inclui um novo conjunto de estatísticas. Ele registra o número de vezes que uma consulta é executada e o tempo que leva para executá-la.

Esta é uma mina de ouro para qualquer pessoa que está monitorando e tentando otimizar o desempenho de uma aplicação que inclui muitas instruções SQL, mas que não é tão fácil de acessar os dados como algumas pessoas desejam.

0
1 228
Pergunta Arian Botine · Nov. 15, 2020

Caché: 2017.2.1.801.0

Fala pessoal, tenho uma dúvida relacionada um problema especifico que eu estou tentando entender, onde ainda não tenho muitas informações, porém estou tentando criar uma forma de levantar dados precisos para expor mais detalhes aqui na comunidade ou até mesmo consultar o suporte da IS, a questão é muito simples:

Precisava saber através de código/rotina a seletividade de uma propriedade de tabela, atualmente consigo realizar um SET utilizando o comando:

SYSTEM.SQL.SetFieldSelectivity("#PACOTE","#TABELA","#PROPRIEDADE","#SELETIVIDADE","")
3
0 213
Artigo Henrique Dias · Out. 26, 2020 3m read

Fala pessoal!


Quero dividir com vocês um projeto pessoal, que iniciou como um simples pedido no meu trabalho: 

É possível saber quantas licenças Caché estamos utilizando? 

Lendo outros artigos aqui na comunidade, eu encontrei este excelente artigo de David Loveluck 


APM - Utilizando Caché History Monitor
https://community.intersystems.com/post/apm-using-cach%C3%A9-history-monitor

Então, utilizando o artigo de David como base, eu comecei a utilizar o Caché History Monitor e a exibir todas as informações.
Quando me deparei com o seguinte dilema: Qual a melhor tecnologia de frontend que eu posso usar?

0
0 218
Artigo Luca Ravazzolo · Out. 6, 2020 4m read

Olá a todos,

Com este artigo eu gostaria de mostrar como o Sistema de Alerta e Monitoramento (ou SAM para abreviar) pode ser configurado de forma fácil e dinâmica. O caso de uso pode ser o de um pipeline de provisionamento de CI/CD, rápido e ágil, onde você deseja executar seus testes unitários mas também seus testes de estresse e, você gostaria de ver rapidamente se esses testes foram bem-sucedidos ou como eles estão estressando os sistemas e sua aplicação (a API SAM é extensível com backend do InterSystems IRIS possibilitando a sua implementação de APM). 

O SAM fornece uma nova interface gráfica que exibe métricas e alertas. Por padrão, ele respeita os alertas gerados pelas instâncias IRIS que monitoradas e, embora você possa definir os valores dos sensores de acordo com sua preferência, o SAM permite que você configure rapidamente regras SAM no Prometheus incluso, para que em seu pipeline de CI/CD você possa ser alertado rapidamente sobre as coisas conforme elas acontecem.

Existem alguns requisitos que você deve prestar atenção para executar o SAM. A solução é disponibilizada em um pacote de contêiner fácil de usar e montado automaticamente utilizando o Docker Compose. Você pode obter todos os detalhes sobre como executar o SAM no link acima. É fácil sorriso

Com o SAM em execução, provisionamos quatro clusters na AWS em quatro regiões diferentes (a empresa fictícia do exemplo é uma organização global e a equipe de garantia de qualidade está localizada nos Estados Unidos, na costa oeste, enquanto a produção está em execução em Londres em um distrito financeiro).

Para provisionar e executar rapidamente nossos clusters IRIS, utilizamos o InterSystems Cloud Manager (ICM) que é configurado de forma rápida e fácil através de scripts simples para implantar estes esses clusters na nuvem, nas várias regiões da AWS.

Quando o processo de provisionamento é concluído, chamamos o script SAM-populate.sh que, configurado adequadamente (veja env-config.sh), popula em poucos segundos nossa solução SAM em execução em nossa estação de trabalho local.

Por meio de uma única página SAM, é possível monitorar vários clusters do InterSystems IRIS sem ter que acessar várias páginas nos portais de gerenciamento da AWS. Legal :) mas, indo direto ao ponto, nós os "IRISanianos"surprise  ficamos surpresos ao ver como nossas instâncias de plataforma de dados estão de fato se saindo quando comparamos a ter apenas as métricas EC2-OS padrão para fazer este tipo de monitoramento. Lembre-se de que o SAM oferece atualmente mais de 100 métricas de kernel do InterSystems IRIS e as combinam com os alertas do InterSystems IRIS. A fusão dos dois deve ser o começo... não de uma história de amor,  mas de uma leitura mais precisa de seus sistemas. 

Você pode encontrar o código do projeto e caso de uso descritos neste link do Github.

Os destaques do projeto são:

  1. O uso da API REST SAM
  2. IU simples, limpa e eficaz do SAM para a visualização de várias instâncias do InterSystems IRIS agrupadas em clusters
  3. O uso da nova funcionalidade de mesclagem do CPF
  4. Potência e capacidade de programação do ICM ou era a capacidade do script? piscadela

Se você deseja executá-lo, preste atenção em: 

  • a necessidade de licenças do InterSystems IRIS com tecnologia sharding habilitada
  • o contêiner InterSystems IRIS certo (você precisará de 2020.2 e superior)
  • o registro do contêiner que o ICM utilizará
  • as credenciais de registro do contêiner
  • o custo em que você incorrerá ao executar esses clusters na AWS
  • e provavelmente algumas outras coisas :)

Espero que você ache os scripts úteis e inspiradores para

  • as chamadas de API REST do SAM e
  • a forma não interativa como o ICM é incrementado

Fiquem bem e seguros

--

0
0 167