Monitorando aplicativos C ++

Estamos implementando uma nova solução de monitoramento centralizado (Zenoss). A incorporação de servidores, redes e programas Java é direta com SNMP e JMX.

A questão, no entanto, é quais são as melhores práticas para monitorar e gerenciar aplicativos C ++ personalizados em ambientes grandes e heterogêneos (Solaris x86, RHEL Linux, Windows)?

As possibilidades que vejo são:

1. SNMP líquido

• Vantagens

1. daemon central único em cada servidor
2. padrão conhecido
3. fácil integração em soluções de monitoramento
4. já executamos daemons Net SNMP em nossos servidores

Desvantagens:

1. implementação complexa (MIBs, biblioteca Net SNMP)
2. nova tecnologia a ser introduzida para os desenvolvedores de C ++

rsyslog

• Vantagens

1. daemon central único em cada servidor
2. padrão conhecido
3. integração desconhecida em soluções de monitoramento (eu sei que eles podem fazer alertas com base em texto, mas como funcionaria para enviar telemetria como uso de memória, profundidade de filas, capacidade de encadeamento etc.)
4. implementação simples

Desvantagens:

1. possíveis problemas de integração
2. tecnologia um pouco nova para desenvolvedores de C ++
3. possíveis problemas de portabilidade se trocarmos de fornecedores de monitoramento
4. provavelmente envolve criar um protocolo de comunicação ad-hoc (ou usar dados estruturados RFC5424; não sei se o Zenoss suporta isso sem a codificação Zenpack personalizada)

JMX incorporado (incorpore uma JVM e use JNI)

• Vantagens

1. interface de gerenciamento consistente para Java e C ++
2. padrão conhecido
3. fácil integração em soluções de monitoramento
4. implementação um tanto simples (já fazemos isso hoje para outros fins)

Desvantagens:

1. complexidade (JNI, camada de conversão entre C ++ nativo e Java, basicamente escrevendo o código de gerenciamento duas vezes)
2. possíveis problemas de estabilidade
3. requer uma JVM em cada processo, usando consideravelmente mais memória
4. JMX é uma nova tecnologia para desenvolvedores de C ++
5. cada processo possui sua própria porta JMX (executamos muitos processos em cada máquina)

Daemon JMX local, processos conectados a ele

• Vantagens

1. daemon central único em cada servidor
2. interface de gerenciamento consistente para Java e C ++
3. padrão conhecido
4. fácil integração em soluções de monitoramento

Desvantagens:

1. complexidade (basicamente escrevendo o código de gerenciamento duas vezes)
2. precisa encontrar ou escrever um daemon
3. precisa de um protocolo entre o daemon JMX e o processo C ++
4. JMX é uma nova tecnologia para desenvolvedores de C ++

CodeMesh JunC ++ ion

• Vantagens

1. interface de gerenciamento consistente para Java e C ++
2. padrão conhecido
3. fácil integração em soluções de monitoramento
4. daemon central único em cada servidor quando executado no modo JVM compartilhado
5. implementação um tanto simples (requer geração de código)

Desvantagens:

1. complexidade (geração de código, requer uma GUI e várias rodadas de ajustes para produzir o código proxy)
2. possíveis problemas de estabilidade JNI
3. requer uma JVM em cada processo, usando consideravelmente mais memória (no modo incorporado)
4. Não suporta Solaris x86 (separador de transações)
5. Mesmo se ele suporta Solaris x86, existem possíveis problemas de compatibilidade do compilador (usamos uma combinação estranha de STLPort e Forte no Solaris
6. cada processo possui sua própria porta JMX quando executado no modo incorporado (executamos muitos processos em cada máquina)
7. possivelmente impede um servidor JMX compartilhado para processos não C ++ (?)

Estou faltando alguma solução simples e razoavelmente padronizada?

Como não há outras soluções razoáveis, qual dessas soluções é normalmente usada para programas C ++ personalizados?

Minha intuição é que o Net SNMP é como as pessoas fazem isso, mas eu gostaria da opinião e experiência de outras pessoas antes de tomar uma decisão.

Não estou familiarizado com o Zenoss, mas quando costumava usar o nagios para esse tipo de coisa, fazia o processo c / c ++ escutar em um soquete e escrever um plug-in personalizado do nagios que fornecia informações de status e diagnóstico.

O primeiro passo é escolher a lib que você deseja usar para fazer seu processo escutar. Algo como o C ++ Socket Library fará isso. Nada complicado lá .. apenas faça o processo escutar.

Então você deve definir a resposta que seu processo enviará, com um estímulo específico. Isso realmente significava (pelo menos com os nagios) definir o 'serviço' e enviar ao processo o sinal que correspondia a esse serviço. A coisa mais simples que você pode fazer é criar um 'processo ping', apenas veja se você pode se conectar com sucesso ao processo em execução. Se você faz isso, o plugin nagios personalizado sabe que pelo menos o processo ainda está ativo.

Você pode fazer coisas muito mais sofisticadas, mas a ideia é bastante simples. Você pode escrever sua própria pequena biblioteca de código de escuta de processo encapsulada em objetos e inseri-la em suas coisas personalizadas de c ++ de maneira padronizada sempre que criar um (ou todos) seus executáveis

O meu entendimento é Zenoss pode fazer isso também .

Provavelmente, já que o Zenoss é python, você escreverá seu plugin personalizado usando algo como Twisted para conectar-se ao seu executável c ++.

não estou familiarizado com esses produtos, mas para o Windows monitore o consumo de memória usando perfmon, existem alguns contadores especiais, como falhas de pool não paginadas, que mostram se o seu programa contém vazamentos de memória, eles podem ser pequenos e levar muito tempo. hora de monitorar, mas na minha opinião, esse é um método simples de verificação.

No Windows, você pode fazer muito usando o perfmon, mesmo remotamente, ou usar o WMI para conectar aos mesmos contadores e fazer alguma automação (no wmi) para executar ações.

Estou entendendo isso, pois recentemente passamos pelo mesmo processo que você: estávamos procurando uma solução leve, sem bloqueio e de código aberto que permita expor e monitorar remotamente as métricas subsequentemente nos serviços C / C ++ ( temos cerca de ~ 3000).

O SNMP chegou mais próximo, mas a integração na fonte e no sistema de monitoramento é uma dor e não é adequada para nossos processos em tempo real.

No final, decidimos desenvolver uma nova solução chamada CMX, que usa a tecnologia de memória compartilhada e a tornou de código aberto. Você pode conferir aqui: www.cern.ch/cmx .

Não estou familiarizado com o lado c ++, mas em Java usamos extensivamente as métricas CodaHale em conjunto com o Graphite . O CodaHale armazena métricas por instância na memória local da instância e usa um encadeamento em segundo plano para liberar métricas para um servidor de grafite a cada minuto (configurável). Em grafite, podemos agregar instâncias e identificar instâncias defeituosas. Se você não deseja a complexidade de manter um cluster de grafite, pode usar o HostedGraphite .

Essa configuração significa que não há um ponto único de falha para a agregação ou relatório de métricas, pois (a agregação com base no tempo ocorre nos próprios nós e a agregação de relatórios ocorre em um cluster de grafite distribuído (ou grafite hospedada).

Por fim, você pode usar Seyren para fornecer alertas sobre os dados de monitoramento.

Se você estiver no Windows, tende a gravar no log de eventos e, em seguida, usa um WMI ou um processo semelhante para ler os eventos. Se você deseja monitorar, adicione contadores de monitor de desempenho ao seu aplicativo e deixe que perfmon os leia. Ambos são serviços do sistema no Windows.

No Linux, obviamente tende a ser mais flexível, mas sempre vi implementados monitores no estilo nagios, com um soquete personalizado enviando dados para um servidor no estilo nagios.

Dito isso, vi vários lugares em que o SMNP é usado e, francamente, não vejo uma razão para você não usá-lo - especialmente se você estiver executando um ambiente completamente heterogêneo.