Monitorar eventos de aplicativos

Visão geral

Neste guia, você pode aprender como configurar e configurar o monitoramento no Driver Ruby do MongoDB.

O monitoramento envolve a coleta de informações sobre as atividades de um programa em execução, que você pode usar com uma biblioteca de gerenciamento de desempenho de aplicação .

Monitorar o driver Ruby permite que você entenda o uso e o desempenho de recursos do driver. Estas informações podem ajudá-lo a tomar decisões informadas ao projetar e depurar seu aplicação.

Neste guia, você pode aprender como executar as seguintes tarefas:

Monitorar eventos de comando
Monitorar eventos de descoberta e monitoramento do servidor (SDAM)
Monitorar eventos do pool de conexões

Este guia mostra como usar informações sobre a atividade do driver no código. Para aprender como fazer o registro de eventos no driver, veja o guia de registro do driver Ruby.

Monitorar eventos de comando

Um evento de comando é um evento relacionado a um comando do banco de dados MongoDB. Você pode acessar um ou mais eventos de monitoramento de comando usando o driver e inscrevendo-os em seu aplicativo.

Para saber mais sobre os comandos do banco de dados MongoDB, consulte o guia Comandos do banco de dados no manual do MongoDB Server.

Inscrever-se para eventos de comando

Você pode acessar detalhes sobre eventos de comando assinando-os em seu aplicação. Você pode se inscrever em eventos em nível global, que monitora todos os clientes de um cluster, ou no nível do cliente . Este exemplo demonstra as seguintes ações:

Instancia um CommandLogSubscriber
Utiliza o método Mongo::Monitoring::Global.subscribe para assinar eventos de comando no nível global
Utiliza o método Mongo::Client.subscribe para assinar eventos de comando no nível do cliente

require 'mongo'
# Creates a subscriber for command monitoringsubscriber = Mongo::Monitoring::CommandLogSubscriber.new
# Globally subscribes to command monitoring eventsMongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, subscriber)
# Replace with your connection string and connect to your clienturi = '<connection string>'client = Mongo::Client.new(uri)
# Subscribes to command monitoring events at the client levelclient.subscribe( Mongo::Monitoring::COMMAND, subscriber)

Descrições de evento

Você pode se inscrever em qualquer um dos seguintes eventos de monitoramento de comandos:

Nome do evento	Descrição
CommandStarted	Criado quando um comando é iniciado.
CommandSucceeded	Criado quando um comando é bem-sucedido.
CommandFailed	Criado quando um comando falhou.

Monitorar eventos de descoberta e monitoramento do servidor (SDAM)

O driver Ruby cria eventos de topologia , também conhecidos como eventos SDAM, quando há uma alteração no estado da instância ou cluster ao qual você se conectou. Por exemplo, o driver cria um evento quando você estabelece uma nova conexão ou se o cluster optar por um novo nó primary.

Para saber mais sobre eventos de topologia, consulte o guia de replicação no manual do servidor.

As seções a seguir demonstram como registrar as alterações de topologia em seu aplicativo e explorar as informações fornecidas nesses eventos.

Inscrever-se para eventos SDAM

Você pode usar o método subscribe do driver Ruby para se inscrever em eventos. Passe um tópico de monitoramento, que define o tipo de evento de monitoramento e um objeto de assinante como argumentos para o método subscribe. Você pode se inscrever em eventos em nível global, que monitora todos os clientes de um cluster, ou no nível do cliente .

Este exemplo demonstra as seguintes ações:

Instancia um assinante ServerOpeningLogSubscriber
Utiliza o método Mongo::Monitoring::Global.subscribe para subscrever eventos do ServerOpening a nível global
Utiliza o método Mongo::Client.subscribe para assinar eventos do ServerOpening no nível do cliente

require 'mongo'
subscriber = Mongo::Monitoring::ServerOpeningLogSubscriber.new
# Globally subscribes to ServerOpening events by using the SERVER_OPENING monitoring topicMongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
# Replace with your connection string and connect to your clienturi = '<connection string>'client = Mongo::Client.new(uri)
# Subscribes to ServerOpening events at the client level by using the SERVER_OPENING monitoring topicclient.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)

A tabela a seguir fornece os assinantes disponíveis e seu tópico de monitoramento:

Nome do assinante	Tópico de monitoramento	Descrição
ServerClosedLogSubscriber	`SERVER_CLOSED`	Inscreve-se em `ServerClosed` eventos e os registra.
ServerDescriptionChangedLogSubscriber	`SERVER_DESCRIPTION_CHANGED`	Inscreve-se em `ServerDescriptionChanged` eventos e os registra.
ServerOpeningLogSubscriber	`SERVER_OPENING`	Inscreve-se em `ServerOpening` eventos e os registra.
TopologiaChangedLogSubscriber	`TOPOLOGY_CHANGED`	Inscreve-se em `TopologyChanged` eventos e os registra.
TopologiaClosedLogSubscriber	`TOPOLOGY_CLOSED`	Inscreve-se em `TopologyClosed` eventos e os registra.
TopologiaOpeningLogSubscriber	`TOPOLOGY_OPENING`	Inscreve-se em `TopologyOpening` eventos e os registra.

Você pode encontrar uma tabela de descrições de evento SDAM na seção Descrições de eventos nesta página.

Monitoramento SDAM personalizado

Você pode criar um assinante SDAM personalizado para acessar detalhes sobre eventos de servidor e topologia . Crie uma classe separada para cada tipo de evento , pois os dados disponíveis para cada evento variam.

Para todos os eventos, o assinante chama o método succeeded e passa o evento como um argumento. Um simples assinante de registro do SDAM pode ter a seguinte aparência:

class SDAMLogSubscriber  include Mongo::Loggable
  def succeeded(event)    log_debug(format_event(event))  end
  private
  def logger    Mongo::Logger.logger  end
  def format_message(message)    format("SDAM | %s", message)  endend  class TopologyOpeningLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Topology type '#{event.topology.display_name}' initializing."  endend
class ServerOpeningLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Server #{event.address} initializing."  endend
class ServerDescriptionChangedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Server description for #{event.address} changed from " +    "'#{event.previous_description.server_type}' to '#{event.new_description.server_type}'."  endend
class TopologyChangedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    if event.previous_topology != event.new_topology      "Topology type '#{event.previous_topology.display_name}' changed to " +      "type '#{event.new_topology.display_name}'."    else      "There was a change in the members of the '#{event.new_topology.display_name}' " +      "topology."    end  endend
class ServerClosedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Server #{event.address} connection closed."  endend
class TopologyClosedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Topology type '#{event.topology.display_name}' closed."  endend

Para assinar eventos, crie o assinante apropriado e assine o tópico de monitoramento correto. O seguinte código mostra como assinar eventos SDAM globalmente:

topology_opening_subscriber = TopologyOpeningLogSubscriber.newserver_opening_subscriber = ServerOpeningLogSubscriber.newserver_description_changed_subscriber = ServerDescriptionChangedLogSubscriber.newtopology_changed_subscriber = TopologyChangedLogSubscriber.newserver_closed_subscriber = ServerClosedLogSubscriber.newtopology_closed_subscriber = TopologyClosedLogSubscriber.new
Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING,  topology_opening_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_OPENING,  server_opening_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED,  server_description_changed_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_CHANGED,  topology_changed_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_CLOSED,  server_closed_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_CLOSED,  topology_closed_subscriber)

O código a seguir mostra como assinar eventos SDAM para um único cliente usando a opção sdam-proc do cliente :

topology_opening_subscriber = TopologyOpeningLogSubscriber.newserver_opening_subscriber = ServerOpeningLogSubscriber.newserver_description_changed_subscriber = ServerDescriptionChangedLogSubscriber.newtopology_changed_subscriber = TopologyChangedLogSubscriber.newserver_closed_subscriber = ServerClosedLogSubscriber.newtopology_closed_subscriber = TopologyClosedLogSubscriber.new
sdam_proc = Proc.new do |client|  client.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING,    topology_opening_subscriber)  client.subscribe(Mongo::Monitoring::SERVER_OPENING,    server_opening_subscriber)  client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED,    server_description_changed_subscriber)  client.subscribe(Mongo::Monitoring::TOPOLOGY_CHANGED,    topology_changed_subscriber)  client.subscribe(Mongo::Monitoring::SERVER_CLOSED,    server_closed_subscriber)  client.subscribe(Mongo::Monitoring::TOPOLOGY_CLOSED,    topology_closed_subscriber)end
client = Mongo::Client.new(['127.0.0.1:27017'], database: 'test',  sdam_proc: sdam_proc)

Observação

A opção :sdam_proc do cliente se aplica somente ao cliente fornecido. Quando determinadas opções do cliente são alteradas usando a chamada Client#with, o driver pode criar um novo cluster com um conjunto padrão de assinantes de evento . Se isso acontecer, o :sdam_proc fornecido não será chamado e o aplicação poderá perder eventos.

Quando você executa o aplicação, seu assinante registra o evento SDAM e gera mensagens como as seguintes:

D, [2018-10-09T13:58:03.489461 #22079] DEBUG -- : SDAM | Topology type 'Unknown' initializing.D, [2018-10-09T13:58:03.489699 #22079] DEBUG -- : SDAM | Server 127.0.0.1:27100 initializing.D, [2018-10-09T13:58:03.491384 #22079] DEBUG -- : SDAM | Server description for 127.0.0.1:27100 changed from 'unknown' to 'unknown'.D, [2018-10-09T13:58:03.491642 #22079] DEBUG -- : SDAM | Server localhost:27100 initializing.D, [2018-10-09T13:58:03.493199 #22079] DEBUG -- : SDAM | Server description for localhost:27100 changed from 'unknown' to 'primary'.D, [2018-10-09T13:58:03.493473 #22079] DEBUG -- : SDAM | Server localhost:27101 initializing.D, [2018-10-09T13:58:03.494874 #22079] DEBUG -- : SDAM | Server description for localhost:27101 changed from 'unknown' to 'secondary'.D, [2018-10-09T13:58:03.495139 #22079] DEBUG -- : SDAM | Server localhost:27102 initializing.D, [2018-10-09T13:58:03.496504 #22079] DEBUG -- : SDAM | Server description for localhost:27102 changed from 'unknown' to 'secondary'.D, [2018-10-09T13:58:03.496777 #22079] DEBUG -- : SDAM | Topology type 'Unknown' changed to type 'ReplicaSetNoPrimary'.D, [2018-10-09T13:58:03.497306 #22079] DEBUG -- : SDAM | Server 127.0.0.1:27100 connection closed.D, [2018-10-09T13:58:03.497606 #22079] DEBUG -- : SDAM | Topology type 'ReplicaSetNoPrimary' changed to type 'ReplicaSetWithPrimary'.
# client.close
D, [2018-10-09T13:58:05.342057 #22079] DEBUG -- : SDAM | Server localhost:27100 connection closed.D, [2018-10-09T13:58:05.342299 #22079] DEBUG -- : SDAM | Server localhost:27101 connection closed.D, [2018-10-09T13:58:05.342565 #22079] DEBUG -- : SDAM | Server localhost:27102 connection closed.D, [2018-10-09T13:58:05.342693 #22079] DEBUG -- : SDAM | Topology type 'ReplicaSetWithPrimary' closed.

servidor Heartbeats

Você também pode criar um assinante personalizado para monitorar as pulsações do servidor , que ocorrem quando o monitor do servidor envia um comando hello para o servidor.

Os assinantes de heartbeat de servidor personalizado diferem de outros assinantes do SDAM, pois eles devem implementar os três métodos a seguir:

started: Invocado quando o ouvinte recebe a pulsação
succeeded: Resposta para um resultado de pulsação bem-sucedido
failed: Resposta para um resultado de falha no batimento cardíaco

O exemplo a seguir mostra um assinante de evento de pulsação:

class HeartbeatLogSubscriber  include Mongo::Loggable
  def started(event)    log_debug("#{event.address} | STARTED")  end
  def succeeded(event)    log_debug("#{event.address} | SUCCEEDED | #{event.duration}s")  end
  def failed(event)    log_debug("#{event.address} | FAILED | #{event.error.class}: #{event.error.message} | #{event.duration}s")  end
  private
  def logger    Mongo::Logger.logger  end
  def format_message(message)    format("HEARTBEAT | %s", message)  endend

Você pode se inscrever em eventos de pulsação globalmente ou para um cliente específico, conforme mostrado no exemplo a seguir:

subscriber = HeartbeatLogSubscriber.new
# Globally subscribes to Server Opening eventsMongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
# Subscribes to Server Opening events at the client levelclient = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'test' )client.subscribe( Mongo::Monitoring::SERVER_HEARTBEAT, subscriber )

Quando você executa o aplicação, seu assinante registra o evento de pulsação e gera mensagens como as seguintes:

D, [2018-09-23T13:44:10.707018 #1739] DEBUG -- : HEARTBEAT | 127.0.0.1:27027 | STARTEDD, [2018-09-23T13:44:10.707778 #1739] DEBUG -- : HEARTBEAT | 127.0.0.1:27027 | SUCCEEDED | 0.000772381s

Descrições de evento

A tabela a seguir fornece o nome e a descrição de cada evento SDAM :

eventType	Descrição
Servidor fechado	Evento criado quando a instância do servidor é fechada.
ServerDescriptionChanged	Evento criado quando a descrição de um servidor muda.
ServerHeatbeatFailed	Evento criado quando um heartbeat de servidor falha.
ServerHeatbeatStarted	Evento criado quando uma pulsação do servidor é recebida pelo ouvinte.
ServerHeatbeatSucceeded	Evento criado quando um heartbeat de servidor é bem-sucedido.
ServerOpening	Evento criado quando o driver se conecta ao servidor.
Topologia alterada	Evento criado quando a topologia muda.
Topologia fechada	Evento criado quando todas as conexões de instância na topologia forem fechadas.
Abertura de topologia	Evento criado antes que o driver tente se conectar a uma instância.

Monitorar eventos do pool de conexões

Um pool de conexões é um conjunto de conexões TCP abertas que seu driver mantém com uma instância MongoDB. Os pools de conexões ajudam a reduzir o número de negociações de rede que seu aplicativo precisa executar e podem ajudá-lo a ser executado mais rapidamente.

As seções a seguir demonstram como registrar eventos de pool de conexões em seu aplicativo e explorar as informações fornecidas nesses eventos.

Assine os eventos do pool de conexões

Você pode acessar detalhes sobre todos os eventos do pool de conexões assinando-os em seu aplicação. Você pode se inscrever em eventos em nível global, que monitora todos os clientes de um cluster, ou em nível do cliente :

Este exemplo demonstra as seguintes ações:

Instancia um assinante CmapLogSubscriber
Usa o método Mongo::Monitoring::Global.subscribe para assinar todos os eventos do pool de conexões em nível global
Utiliza o método Mongo::Client.subscribe para assinar todos os eventos do pool de conexões no nível do cliente

require 'mongo'
# Creates a subscriber for connection pool monitoringsubscriber = Mongo::Monitoring::CmapLogSubscriber.new
# Globally subscribes to connection pool monitoring eventsMongo::Monitoring::Global.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
# Replace with your connection string and connect to your clienturi = '<connection string>'client = Mongo::Client.new(uri)
# Subscribes to connection pool monitoring events at the client levelclient.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)

Descrições de evento

Você pode assinar qualquer um dos seguintes eventos de monitoramento do pool de conexões:

Nome do evento	Descrição
connectionCheckOutFailed	Criado quando uma operação falha ao estabelecer uma conexão para execução.
connectionCheckOutStarted	Criado quando uma operação tenta adquirir uma conexão para execução.
connectionCheckedIn	Criado quando uma conexão é verificada novamente no pool depois que uma operação é executada.
connectionCheckedOut	Criado quando uma operação adquire com sucesso uma conexão para execução.
connectionClosed	Criado quando uma conexão é fechada.
connectionCreated	Criado quando uma conexão é criada, mas não necessariamente quando é usada para uma operação.
connectionReady	Criado após uma conexão ter concluído com êxito um handshake e estar pronta para ser usada em operações.
PoolLimpo	Criado quando todas as conexões forem fechadas e o pool de conexões for limpo.
PoolClosed	Criado quando um pool de conexões é fechado antes da destruição da instância do servidor.
PoolCreated	Criado quando um pool de conexões é criado.
PoolReady	Criado quando um pool de conexões estiver pronto.

Documentação da API

Para saber mais sobre qualquer uma das classes ou métodos discutidos neste guia, consulte a seguinte documentação da API:

Voltar

MongoDB Vector Search

Exploração madeireira