Journalisation et diagnostics

Le Client SDK propose une fonctionnalité de journalisation configurable destinée à faciliter l'intégration, le débogage et la surveillance en production. Les journaux couvrent le trafic HTTP interne, les appels d'API, les événements WebRTC et le cycle de vie des sessions.

Niveaux de journalisation

Définissez le niveau de journalisation lors de la création du client. Niveaux disponibles, du plus détaillé au moins détaillé :

Niveau	Cas d'utilisation
`Verbose`	Sortie de trace complète — utile lors de l'intégration initiale
`Debug`	Informations détaillées sur le diagnostic
`Info`	Messages opérationnels généraux
`Warn`	Problèmes potentiels qui n'empêchent pas le fonctionnement
`Error`	Échecs uniquement
`None`	Journalisation désactivée

Configuration

Vous pouvez définir directement un niveau de journalisation, désactiver complètement le module de journalisation interne ou fournir des implémentations personnalisées de ce module afin de rediriger les données de sortie du SDK vers votre propre infrastructure de journalisation.

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];

Enregistreurs personnalisés

Les enregistreurs personnalisés reçoivent des événements de journalisation structurés contenant :

niveau — le niveau de gravité de l'entrée du journal
sujet — classe la source du journal (par exemple : HTTP, API, WebRTC)
message — le contenu du journal

Utilisez des enregistreurs personnalisés pour intégrer les diagnostics du SDK à vos outils existants de journalisation ou de signalement des plantages (par exemple, Sentry, Datadog, Crashlytics).

Filtrage par thème

Chaque enregistreur peut s'abonner à des sujets spécifiques afin de réduire le bruit. Les groupes de sujets disponibles sont les suivants : HTTP, API, entre autres. Le filtrage par thème s'avère utile en production, lorsque l'on souhaite uniquement capturer les événements au niveau du réseau sans consigner en détail l'état interne du système.

Recommandations

Utilisation Verbose au cours du développement et de l'intégration initiale, afin de comprendre le déroulement des appels et l'ordre des événements.
Utilisation Error ou Warn dans les versions de production afin de réduire au minimum l'impact sur les performances.
Si vous avez besoin de diagnostics de production sans niveau de détail maximal, utilisez un enregistreur de journaux personnalisé filtré selon des thèmes spécifiques.