Registros e Diagnósticos

O Client SDK oferece um sistema de registro de logs configurável para auxiliar na integração, na depuração e no monitoramento em produção. As informações registradas abrangem o tráfego HTTP interno, chamadas de API, eventos WebRTC e o ciclo de vida da sessão.

Níveis de registro

Defina o nível de registro ao criar o cliente. Níveis disponíveis, do mais detalhado ao menos detalhado:

Nível	Caso de uso
`Verbose`	Saída completa do rastreamento — útil durante a integração inicial
`Debug`	Informações detalhadas de diagnóstico
`Info`	Mensagens operacionais gerais
`Warn`	Possíveis problemas que não impedem o funcionamento
`Error`	Apenas falhas
`None`	Registro desativado

Configuração

Você pode definir um nível de registro diretamente, desativar totalmente o registrador interno ou fornecer implementações personalizadas do registrador que encaminhem a saída do SDK para sua própria infraestrutura de registro.

const clientA = new VonageClient({
  loggingLevel: LoggingLevel.Error
});
// or setup custom loggers
const clientB = new VonageClient({
  disableInternalLogger: true,
  customLoggers: [
    {
      name: 'CustomLoggerOne',
      minLogLevel: LoggingLevel.Debug,
      topics: ['HTTP', Topics.API],
      onLog: (level, topic, message) => {
        console.log(`${level} ${topic.name} ${topic.tag} ${message}`);
      }
    },
    createVonageLogger('CustomLoggerTwo', (level, topic, message) => {
      console.log(`${level} ${topic.name} ${topic.tag} ${message}`);
    })
  ]
});

 val config = VGClientInitConfig(LoggingLevel.Verbose)
 val clientA = VonageClient(ctx, config)
 // or
 val clientB = VonageClient(
     ctx,
     VGClientInitConfig().apply {
         loggingLevel = LoggingLevel.Error
     }
 )
 // or setup custom loggers
 val clientC = VonageClient(
     ctx,
     VGClientInitConfig(
         disableInternalLogger = true,
         customLoggers = listOf(
             object : VonageLogger {
                 override val name: String = "CustomLoggerOne"
                 override val minLogLevel: LoggingLevel = LoggingLevel.Debug
                 override val topics: List<Topic> = listOf(Topic.HTTP, Topic.API).flatten()
                 override fun onLog(logLevel: LoggingLevel, topic: Topic, message: String, throwable: Throwable?) {
                     println("$logLevel ${topic.name} ${topic.tag} $message")
                 }
             },
             createVonageLogger("CustomLoggerTwo"){ logLevel, topic, message, _ ->
                 println("$logLevel ${topic.name} ${topic.tag} $message")
             }
         )
     )
 )

 LoggingLevel logLevelA = LoggingLevel.Verbose;
 VGClientInitConfig configA = new VGClientInitConfig(logLevelA);
 VonageClient clientA = VonageClient.createClient(ctx, configA);
 // or
 VGClientInitConfig configB = new VGClientInitConfig();
 configB.setLoggingLevel(LoggingLevel.Error);
 VonageClient clientB = VonageClient.createClient(ctx, configB);
 // or setup custom loggers
 VGClientInitConfig configC = new VGClientInitConfig();
 configC.setDisableInternalLogger(true);
 configC.setCustomLoggers(Arrays.asList(
         new VonageLogger() {
             @NotNull
             @Override
             public String getName() {
                 return "CustomLoggerOne";
             }

             @NotNull
             @Override
             public LoggingLevel getMinLogLevel() {
                 return LoggingLevel.Debug;
             }

             @NotNull
             @Override
             public List<Topic> getTopics() {
                 List<Topic> flattenedList = new ArrayList<>();
                 for (List<? extends Topic> subList : Arrays.asList(Topic.Companion.getHTTP(), Topic.Companion.getAPI())) {
                     flattenedList.addAll(subList);
                 }
                 return flattenedList;
             }

             @Override
             public void onLog(@NotNull LoggingLevel logLevel, @NotNull Topic topic, @NotNull String message, Throwable throwable) {
                 System.out.println(logLevel + " " + topic.getName() + " " + topic.getTag() + " " + message);
             }
         },
         createVonageLogger(
                 "CustomLoggerTwo",
                 null, null,
                 (logLevel, topic, message, throwable) -> {
                     System.out.println(logLevel + " " + topic.getName() + " " + topic.getTag() + " " + message);
                     return null;
                 }
         )
 ));
 VonageClient clientC = VonageClient.createClient(ctx, configC);

 let configA = VGClientInitConfig(loggingLevel: .verbose)
 let clientA = VGVonageClient(configA)
 // or
 let configB = VGClientInitConfig()
 configB.loggingLevel = .error
 let clientB = VGVonageClient(configB)
 // or setup custom loggers
 class MyLogger : NSObject, VGLogger {
     let name: String = "CustomLoggerOne"

     let minLogLevel: VGLoggingLevel = .debug

     let topics: [VGTopicGroup] = [VGTopic.HTTP, VGTopic.API]

     func didReceiveLog(logLevel: VGLoggingLevel, topic: VGTopic, message: String) {
         print("\(logLevel) \(topic.name) \(topic.tag) \(message)")
     }
 }
 let clientC = VGVonageClient(
     VGClientInitConfig(
         disableInternalLogger: true,
         customLoggers: [
             MyLogger(),
             VGCustomLogger("CustomLoggerTwo"){ logLevel,topic, message in
                 print("\(logLevel) \(topic.name) \(topic.tag) \(message)")
             }
         ]
     )
 )

 VGClientInitConfig *configA = [[VGClientInitConfig alloc]
                                initWithLoggingLevel:VGLoggingLevelVerbose
                                disableInternalLogger:VGDefaultDisableInternalLogger
                                customLoggers:[NSArray array]
                                region:VGDefaultRegion
                                apiUrl:nil
                                websocketUrl:nil
                                websocketPath:nil
                                enableWebSocketInvites:VGDefaultEnableWebsocketInvites
                                rtcStatsTelemetry:VGDefaultRtcStatsTelemetry
                                autoReconnectMedia:VGDefaultAutoReconnectMedia
                                enableNoiseSuppression:VGDefaultEnableNoiseSuppression
                                emergencyPrimaryRegion:nil
                                emergencySecondaryRegion:nil];
 VGVonageClient* clientA = [[VGVonageClient alloc] initWithConfig:configA];
 // or
 VGClientInitConfig *configB = [[VGClientInitConfig alloc] init];
 configB.loggingLevel = VGLoggingLevelError;
 VGVonageClient* clientB = [[VGVonageClient alloc] initWithConfig:configB];
 // or setup custom loggers
 // 1. Implement the VGLogger protocol
 id<VGLogger> customLoggerOne;
 // 2. Use the VGCustomLogger class
 VGCustomLogger *customLoggerTwo = [[VGCustomLogger alloc]
                                    initWithName:@"CustomLoggerTwo"
                                    minLogLevel:VGDefaultLoggingLevel()
                                    topics:VGDefaultTopics()
                                    onLog:^(VGLoggingLevel logLevel, VGTopic * _Nonnull topic, NSString * _Nonnull message) {
     NSLog(@"%ld %@ %@ %@", logLevel, topic.name, topic.tag, message);
 }];
 VGClientInitConfig *configC = [[VGClientInitConfig alloc] init];
 configC.disableInternalLogger = true;
 configC.customLoggers = [NSArray arrayWithObjects:customLoggerOne, customLoggerTwo, nil];
 VGVonageClient *clientC = [[VGVonageClient alloc] initWithConfig:configC];

Registradores personalizados

Os registradores personalizados recebem eventos de log estruturados com:

nível — o nível de gravidade da entrada no log
tópico — classifica a origem do registro (por exemplo, HTTP, API, WebRTC)
mensagem — o conteúdo do log

Use registradores personalizados para integrar os diagnósticos do SDK às suas ferramentas existentes de registro de logs ou de relatório de falhas (por exemplo, Sentry, Datadog, Crashlytics).

Filtragem por tópico

Cada registrador pode se inscrever em tópicos específicos para reduzir o ruído. Os grupos de tópicos disponíveis incluem HTTP, API, entre outros. A filtragem por tópico é útil em ambiente de produção, onde talvez você queira capturar apenas eventos no nível da rede, sem um registro detalhado do estado interno.

Recomendações

Uso Verbose durante o desenvolvimento e a integração inicial, para compreender o fluxo de chamadas e a sequência dos eventos.
Uso Error ou Warn nas versões de produção, a fim de minimizar a sobrecarga de desempenho.
Se você precisar de diagnósticos de produção sem todos os detalhes, use um registrador personalizado filtrado por tópicos específicos.