StatsN

StatistiquesN

StatsN est un client Stastd moderne et performant pour dotnet core. StatsN prend en charge à la fois TCP et UDP, bien que UDP soit recommandé. Largement inspiré du client statsd-csharp et du client statsd.net. Dans mon esprit, les deux projets sont géniaux ?, mais pas exactement ce que je recherchais.

J'ai écrit ce client parce que je trouvais les tests unitaires statiques moins amusants et que j'en avais marre d'attendre la publication des fonctionnalités. Ou la prise en charge de fonctionnalités que statsd ne prend pas réellement en charge.

Ce client tente d'aider à la testabilité en utilisant des interfaces, à l'observabilité en vous permettant d'enregistrer des fonctions pour écouter les exceptions et la journalisation qui se produisent à l'intérieur du client, et à l'évolutivité en permettant au code de fonctionner correctement.

Commencer

 Install-Package StatsN

Bref, l'API est simple. Vous pouvez obtenir un nouveau IStatsd de différentes manières, puis enregistrer les métriques avec une implémentation d'IStatsd. Voici quelques exemples.

Remarque : vous souhaiterez stocker votre IStatsd en tant que singleton (très probablement dans un conteneur DI). Ce type conserve une connexion TCP ou UDP. Les fonctions du client sont thread-safe.

 IStatsd statsd = Statsd . New < Udp > ( a => a . HostOrIp = "10.22.2.1" , Port = 8125 , Prefix = "MyMicroserviceName" ) ;
IStatsd statsd = Statsd . New < Tcp > ( a => a . HostOrIp = "10.22.2.1" ) ; //use tcp
IStatsd statsd = Statsd . New < NullChannel > ( a => a . HostOrIp = "10.22.2.1" , Port = 8125 ) ; //pipes your metrics to nowhere...which can scale infinately btw
IStatsd statsd = Statsd . New ( a => a . HostOrIp = "10.22.2.1" ) ; //defaults to udp
IStatsd statsd = Statsd . New ( new StatsdOptions ( ) { HostOrIp = "127.0.0.1" } ) ; //defaults to udp
IStatsd statsd = new Stastd ( new StatsdOptions ( ) { HostOrIp = "127.0.0.1" } ) ;  //defaults to udp
IStatsd statsd = new Stastd ( new StatsdOptions ( ) { HostOrIp = "127.0.0.1" } , new Tcp ( ) ) ; //pass a new udp client. You could in theory make your own transport if you inherit from BaseCommunicationProvider


statsd . CountAsync ( "myapp.counterstat" ) ; //default to 1 aka increment
statsd . CountAsync ( "myapp.counterstat" , 6 ) ;
statsd . CountAsync ( "myapp.counterstat" , - 6 ) ;
statsd . TimerAsync ( "myapp.timeMyFunction" , ( ) => {
 //code to instrument
} ) ;
statsd . TimerAsync ( "myapp.timeData" , 400 ) ; //400ms
statsd . GaugeAsync ( "autotest.gaugeyo" , 422 ) ;
statsd . GaugeDeltaAsync ( "autotest.gaugeyo" , - 10 ) ;
statsd . SetAsync ( "autotest.setyo" , 888 ) ; 

Enregistrement

Comme la plupart des clients statsd, ce client évite à tout prix de lever des exceptions . Toutes les erreurs/exceptions créées seront enregistrées sous forme de messages Systems.Diagnostics.Trace.

Vous pouvez transmettre lambda dans la classe StatsdOptions pour transmettre les exceptions et les messages de journalisation, au lieu de les transmettre via le système Trace.

            var opt = new StatsdOptions
            {
                OnExceptionGenerated = ( exception ) => { /* handle exception */ } ,
				OnLogEventGenerated = ( log ) => { /* handle log msg */ }
            } ;
			var stats = Statsd . New ( opt ) ;

ou

 var stats = Statsd . New ( a => a . OnExceptionGenerated = ( exception ) => { /* handle exception */ } ) ; 

Métriques de mise en mémoire tampon

En définissant la propriété BufferMetrics dans l'objet options sur true, les métriques seront mises en mémoire tampon, envoyant ainsi moins de paquets. La taille du tampon est par défaut de 512, ce qui est documenté par statsd. Vous pouvez modifier sa taille à l'aide de la propriété BufferSize de StastdOptions . Cela utilise une file d'attente simultanée pour mettre en file d'attente les métriques et un BackgroundWorker pour retirer les métriques de la file d'attente et les envoyer sous forme agrégée.

 var opt = new StatsdOptions ( ) {

    BufferMetrics = true ,
    BufferSize = 512
} ; 

En attente de métriques

Par défaut, les différentes fonctions de métrique de journalisation renvoient des tâches. Vous n'avez pas besoin d'attendre sur ces derniers. Si vous les attendez et que vous avez mis les métriques en mémoire tampon, vous reviendrez après que les octets aient été ajoutés au flux réseau. Si vous attendez et que les métriques mises en mémoire tampon sont activées, votre attente reviendra lorsque votre métrique aura été ajoutée à la file d'attente des métriques à envoyer.

point net 4.0

Bien que ce projet cible dotnet 4.0, les tests unitaires ne s'exécutent pas dans 4.0. Le support est limité (les nouvelles fonctionnalités peuvent ne pas être disponibles sur dotnet 4.S), mais les bugs seront corrigés.

Configuration du développeur

Si vous envisagez de jouer avec le code, assurez-vous de télécharger et d'installer le SDK Core .NET.