public void SampleRate()
{
var config = new StatsdConfig
{
StatsdServerName = "127.0.0.1",
StatsdPort = 1234,
};
config.ClientSideAggregation = new ClientSideAggregationConfig {
};
using (var server = new SocketServer(config))
{
using (var service = new DogStatsdService())
{
service.Configure(config);
for (int i = 0; i < 500; i++)
{
service.Increment("test1", 1, 0.5);
service.Increment("test1", 1, 0.3);
service.Increment("test1", 1, 0.8);
}
}
var metric = server.Stop().Single();
var match = Regex.Match(metric, @"^test1:(.*)\|c$");
Assert.True(match.Success);
var metricValue = double.Parse(match.Groups[1].Value);
Assert.AreEqual(500.0 * 3, metricValue, delta: 100);
}
}
public void Init()
{
_service = new DogStatsdService();
_config = new StatsdConfig {
StatsdServerName = "localhost"
};
}
private static DogStatsdService CreateService(
TemporaryPath temporaryPath,
HostnameProvider hostnameProvider = HostnameProvider.Property)
{
var serverName = StatsdBuilder.UnixDomainSocketPrefix + temporaryPath.Path;
var dogstatsdConfig = new StatsdConfig {
StatsdMaxUnixDomainSocketPacketSize = 1000
};
switch (hostnameProvider)
{
case HostnameProvider.Property: dogstatsdConfig.StatsdServerName = serverName; break;
case HostnameProvider.Environment:
{
Environment.SetEnvironmentVariable(StatsdConfig.AgentHostEnvVar, serverName);
break;
}
}
var dogStatsdService = new DogStatsdService();
dogStatsdService.Configure(dogstatsdConfig);
return(dogStatsdService);
}
private static void CheckReconnection(StatsdConfig config)
{
SocketServer server = null;
try
{
server = new SocketServer(config);
using (var service = new DogStatsdService())
{
service.Configure(config);
service.Increment("test1");
Assert.AreEqual("test1:1|c", server.Stop().Single());
server.Dispose();
// Send a metric when the server is not running.
service.Increment("test2");
Task.Delay(TimeSpan.FromMilliseconds(500)).Wait();
// Restart the server
server = new SocketServer(config, removeUDSFileBeforeStarting: true);
service.Increment("test3");
service.Dispose();
Assert.AreEqual("test3:1|c", server.Stop().Last());
}
}
finally
{
server?.Dispose();
}
}
public static IServiceCollection AddStatsD(this IServiceCollection services, IHostEnvironment environment, IConfiguration configuration)
{
var cfg = new StatsdConfig {
Prefix = "modix"
};
var enableStatsd = configuration.GetValue <bool>(nameof(ModixConfig.EnableStatsd));
if (!enableStatsd ||
!environment.IsProduction() && string.IsNullOrWhiteSpace(cfg.StatsdServerName))
{
services.AddSingleton <IDogStatsd, DebugDogStatsd>();
return(services);
}
DogStatsd.Configure(cfg);
services.AddSingleton(cfg);
services.AddSingleton <IDogStatsd>(provider =>
{
var config = provider.GetRequiredService <StatsdConfig>();
var service = new DogStatsdService();
service.Configure(config);
return(service);
});
return(services);
}
public void Setting_entity_id_with_env_arg()
{
Environment.SetEnvironmentVariable("DD_ENTITY_ID", "foobar");
using (var nonStaticServiceInstance = new DogStatsdService())
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1",
StatsdPort = 8132,
};
nonStaticServiceInstance.Configure(metricsConfig);
var receivedData = ReceiveData(
nonStaticServiceInstance,
"127.0.0.1",
8132,
() => { nonStaticServiceInstance.Increment("test"); });
Assert.AreEqual(new List <string> {
"test:1|c|#dd.internal.entity_id:foobar"
}, receivedData);
}
Environment.SetEnvironmentVariable("DD_ENTITY_ID", null);
}
private static void CheckReconnection(
Func <StatsdConfig, AbstractServer> serverFactory,
StatsdConfig config)
{
AbstractServer server = null;
try
{
server = serverFactory(config);
using (var service = new DogStatsdService())
{
service.Configure(config);
service.Increment("test1");
Assert.AreEqual("test1:1|c", server.Stop().Single());
server.Dispose();
// Send a metric when the server is not running.
service.Increment("test2");
Task.Delay(TimeSpan.FromMilliseconds(500)).Wait();
// Restart the server
server = serverFactory(config);
service.Increment("test3");
service.Dispose();
Assert.AreEqual("test3:1|c", server.Stop().Last());
}
}
finally
{
server?.Dispose();
}
}
public DatadogTelemetryConsumer()
{
var config = new StatsdConfig();
_service = new DogStatsdService();
_service.Configure(config);
}
public void Setting_tag_with_env_arg(string envVar, string tag)
{
Environment.SetEnvironmentVariable(envVar, "foobar");
try
{
using (var nonStaticServiceInstance = new DogStatsdService())
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1",
StatsdPort = 8132,
};
nonStaticServiceInstance.Configure(metricsConfig);
var receivedData = ReceiveData(
nonStaticServiceInstance,
"127.0.0.1",
8132,
() => { nonStaticServiceInstance.Increment("test"); });
Assert.AreEqual(new List <string> {
$"test:1|c|#{tag}:foobar"
}, receivedData);
}
}
finally
{
Environment.SetEnvironmentVariable(envVar, null);
}
}
public TelemetryService(ILogger <TelemetryService> logger)
{
if (TelemetryConfig.statsdConfig != null)
{
dogStatsdService = new DogStatsdService();
dogStatsdService.Configure(TelemetryConfig.statsdConfig);
}
this.logger = logger;
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(serverName, _serverPort);
var metricsConfig = new StatsdConfig {
StatsdServerName = serverName, StatsdPort = _serverPort
};
_dogStatsdService = new DogStatsdService();
_dogStatsdService.Configure(metricsConfig);
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(serverName, _serverPort);
var metricsConfig = new StatsdConfig {
StatsdServerName = serverName, StatsdPort = _serverPort
};
metricsConfig.Advanced.TelemetryFlushInterval = TimeSpan.FromDays(1);
_dogStatsdService = new DogStatsdService();
_dogStatsdService.Configure(metricsConfig);
}
public void SetUpUdpListenerAndStatsd()
{
_udpListener = new UdpListener(_serverName, _serverPort);
var metricsConfig = new StatsdConfig {
StatsdServerName = _serverName
};
_dogStatsdService = new DogStatsdService();
_dogStatsdService.Configure(metricsConfig);
_udp = new StatsdUDP(_serverName, _serverPort);
_statsd = new Statsd(_udp);
}
public void StartUdpListenerThread()
{
_listenThread = new Thread(new ParameterizedThreadStart(_udpListener.Listen));
_listenThread.Start();
var metricsConfig = new StatsdConfig {
StatsdServerName = serverName, StatsdPort = _serverPort
};
metricsConfig.ClientSideAggregation = _optionalClientSideAggregationConfig;
metricsConfig.Advanced.TelemetryFlushInterval = TimeSpan.FromDays(1);
_dogStatsdService = new DogStatsdService();
_dogStatsdService.Configure(metricsConfig);
}
private static IDogStatsd CreateDogStatsdClient(TracerSettings settings, string serviceName, int port)
{
try
{
var constantTags = new List <string>
{
"lang:.NET",
$"lang_interpreter:{FrameworkDescription.Instance.Name}",
$"lang_version:{FrameworkDescription.Instance.ProductVersion}",
$"tracer_version:{TracerConstants.AssemblyVersion}",
$"service:{serviceName}"
};
if (settings.Environment != null)
{
constantTags.Add($"env:{settings.Environment}");
}
if (settings.ServiceVersion != null)
{
constantTags.Add($"version:{settings.ServiceVersion}");
}
var statsd = new DogStatsdService();
if (AzureAppServices.Metadata.IsRelevant)
{
// Environment variables set by the Azure App Service extension are used internally.
// Setting the server name will force UDP, when we need named pipes.
statsd.Configure(new StatsdConfig
{
ConstantTags = constantTags.ToArray()
});
}
else
{
statsd.Configure(new StatsdConfig
{
StatsdServerName = settings.AgentUri.DnsSafeHost,
StatsdPort = port,
ConstantTags = constantTags.ToArray()
});
}
return(statsd);
}
catch (Exception ex)
{
Log.Error(ex, $"Unable to instantiate {nameof(Statsd)} client.");
return(new NoOpStatsd());
}
}
protected QueueProcessor(QueueConfiguration config)
{
this.config = config;
const string queue_prefix = "osu-queue:";
inputQueueName = $"{queue_prefix}{config.InputQueueName}";
DogStatsd = new DogStatsdService();
DogStatsd.Configure(new StatsdConfig
{
StatsdServerName = Environment.GetEnvironmentVariable("DD_AGENT_HOST") ?? "localhost",
Prefix = $"osu.server.queues.{config.InputQueueName}"
});
}
private void testReceive(string testServerName, int testPort, string testCounterName,
string expectedOutput, DogStatsdService dogStatsdService)
{
UdpListener udpListener = new UdpListener(testServerName, testPort);
Thread listenThread = new Thread(new ParameterizedThreadStart(udpListener.Listen));
listenThread.Start();
dogStatsdService.Increment(testCounterName);
while (listenThread.IsAlive)
{
;
}
Assert.AreEqual(expectedOutput, udpListener.GetAndClearLastMessages()[0]);
udpListener.Dispose();
}
private List <string> ReceiveData(DogStatsdService dogstasdService, string testServerName, int testPort, Action sendData)
{
using (var udpListener = new UdpListener(testServerName, testPort))
{
var listenThread = new Thread(udpListener.ListenAndWait);
listenThread.Start();
sendData();
dogstasdService.Dispose();
udpListener.Shutdown();
listenThread.Join();
return(udpListener.GetAndClearLastMessages());
}
}
public void setting_port_listen_on_other_port_should_return_no_data()
{
using (var nonStaticServiceInstance = new DogStatsdService())
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1",
StatsdPort = 8126
};
nonStaticServiceInstance.Configure(metricsConfig);
var receivedData = ReceiveData(nonStaticServiceInstance, "127.0.0.1", 8125,
() => { nonStaticServiceInstance.Increment("test"); });
Assert.AreEqual(0, receivedData.Count);
}
}
/// <summary>
/// Add a health check publisher for Datadog.
/// </summary>
/// <remarks>
/// For each <see cref="HealthReport"/> published a custom service check indicating the health check status (OK - Healthy, WARNING - Degraded, CRITICAL - Unhealthy)
/// and a metric indicating the total time the health check took to execute on milliseconds is sent to Datadog./>
/// </remarks>
/// <param name="builder">The <see cref="IHealthChecksBuilder"/>.</param>
/// <param name="serviceCheckName">Specifies the name of the custom check and metric that will be published to datadog. Example: "myservice.healthchecks".</param>
/// <param name="datadogAgentName">Specified Datadog agent server name. Defaults to localhost address 127.0.0.1.</param>
/// <param name="defaultTags">Specifies a collection of tags to send with the custom check and metric.</param>
/// <returns>The <see cref="IHealthChecksBuilder"/>.</returns>
public static IHealthChecksBuilder AddDatadogPublisher(this IHealthChecksBuilder builder, string serviceCheckName, string datadogAgentName = "127.0.0.1", string[] defaultTags = default)
{
builder.Services
.AddSingleton <IHealthCheckPublisher>(_ =>
{
var dogStatsdService = new DogStatsdService();
dogStatsdService.Configure(new StatsdConfig
{
StatsdServerName = datadogAgentName
});
return(new DatadogPublisher(dogStatsdService, serviceCheckName, defaultTags));
});
return(builder);
}
public void default_port_is_8125()
{
using (var nonStaticServiceInstance = new DogStatsdService())
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1"
};
nonStaticServiceInstance.Configure(metricsConfig);
var receivedData = ReceiveData(nonStaticServiceInstance, "127.0.0.1", 8125,
() => { nonStaticServiceInstance.Increment("test"); });
Assert.AreEqual(new List <string> {
"test:1|c"
}, receivedData);
}
}
public void setting_prefix()
{
using (var nonStaticServiceInstance = new DogStatsdService())
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1",
StatsdPort = 8129,
Prefix = "prefix"
};
nonStaticServiceInstance.Configure(metricsConfig);
var receivedData = ReceiveData(nonStaticServiceInstance, "127.0.0.1", 8129,
() => { nonStaticServiceInstance.Increment("test"); });
Assert.AreEqual(new List <string> {
"prefix.test:1|c"
}, receivedData);
}
}
public void Setting_prefix_starttimer()
{
using (var nonStaticServiceInstance = new DogStatsdService())
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1",
StatsdPort = 8130,
Prefix = "prefix",
};
nonStaticServiceInstance.Configure(metricsConfig);
var receivedData = ReceiveData(
nonStaticServiceInstance,
"127.0.0.1",
8130,
() =>
{
using (nonStaticServiceInstance.StartTimer("timer.test"))
{
Thread.Sleep(1000);
}
});
Assert.AreEqual(1, receivedData.Count);
var metricResultSplit = receivedData[0].Split(':');
Assert.AreEqual(2, metricResultSplit.Length);
var metricNameWithPrefix = metricResultSplit[0];
var metricTimeAndType = metricResultSplit[1];
Assert.AreEqual("prefix.timer.test", metricNameWithPrefix);
var metricTimeInMsSplit = metricTimeAndType.Split('|');
Assert.AreEqual(2, metricTimeInMsSplit.Length);
var metricTimeInMs = Convert.ToInt32(metricTimeInMsSplit[0]);
Assert.IsTrue((metricTimeInMs >= 1000), "Processing should have taken at least 1000ms");
Assert.IsTrue((metricTimeInMs < 1300), $"Timer reported 30% higher than time taken in action: {metricTimeInMs} VS 1300");
}
}
public void setting_with_env_arg()
{
Environment.SetEnvironmentVariable("DD_DOGSTATSD_PORT", "8131");
Environment.SetEnvironmentVariable("DD_AGENT_HOST", "127.0.0.1");
using (var nonStaticServiceInstance = new DogStatsdService())
{
var metricsConfig = new StatsdConfig {
};
nonStaticServiceInstance.Configure(metricsConfig);
var receivedData = ReceiveData(nonStaticServiceInstance, "127.0.0.1", 8131,
() => { nonStaticServiceInstance.Increment("test"); });
Assert.AreEqual(new List <string> {
"test:1|c"
}, receivedData);
}
Environment.SetEnvironmentVariable("DD_DOGSTATSD_PORT", null);
Environment.SetEnvironmentVariable("DD_AGENT_HOST", null);
}
private static IDogStatsd CreateDogStatsdClient(TracerSettings settings, string serviceName, int port)
{
try
{
var frameworkDescription = FrameworkDescription.Create();
var constantTags = new List <string>
{
"lang:.NET",
$"lang_interpreter:{frameworkDescription.Name}",
$"lang_version:{frameworkDescription.ProductVersion}",
$"tracer_version:{TracerConstants.AssemblyVersion}",
$"service:{serviceName}"
};
if (settings.Environment != null)
{
constantTags.Add($"env:{settings.Environment}");
}
if (settings.ServiceVersion != null)
{
constantTags.Add($"version:{settings.ServiceVersion}");
}
var statsd = new DogStatsdService();
statsd.Configure(new StatsdConfig
{
StatsdServerName = settings.AgentUri.DnsSafeHost,
StatsdPort = port,
ConstantTags = constantTags.ToArray()
});
return(statsd);
}
catch (Exception ex)
{
Log.SafeLogError(ex, $"Unable to instantiate {nameof(Statsd)} client.");
return(new NoOpStatsd());
}
}
private void TestReceive(
string testServerName,
int testPort,
string testCounterName,
string expectedOutput,
DogStatsdService dogStatsdService)
{
using (UdpListener udpListener = new UdpListener(testServerName, testPort))
{
Thread listenThread = new Thread(udpListener.ListenAndWait);
listenThread.Start();
dogStatsdService.Increment(testCounterName);
dogStatsdService.Dispose();
udpListener.Shutdown();
listenThread.Join();
Assert.AreEqual(expectedOutput, udpListener.GetAndClearLastMessages()[0]);
}
}
public void GlobalSetup()
{
_agent.Bind(Endpoint);
_datadogStatsD = new DogStatsD(new DogStatsDConfiguration
{
EndPoint = Endpoint,
Namespace = Namespace,
ConstantTags = ParseTags(ConstantTags).ToArray(),
}).CreateCount(MetricName, ParseTags(Tags).ToArray());
_datadogSharp = new DatadogSharp.DogStatsd.DatadogStats(Endpoint.Address.ToString(), Endpoint.Port,
Namespace, ConstantTags);
_dogStatsDService = new DogStatsdService();
_dogStatsDService.Configure(new StatsdConfig
{
Prefix = Namespace,
ConstantTags = ConstantTags,
StatsdServerName = Endpoint.Address.ToString(),
StatsdPort = Endpoint.Port
});
}
private static void SendAndCheckMetricsAreReceived(StatsdConfig config, int metricToSendCount)
{
using (var service = new DogStatsdService())
{
using (var server = new SocketServer(config))
{
service.Configure(config);
for (int i = 0; i < metricToSendCount; ++i)
{
service.Increment($"test{i}", tags: new[] { "KEY:VALUE" });
}
service.Dispose();
var metricsReceived = server.Stop();
Assert.AreEqual(metricToSendCount, metricsReceived.Count);
for (int i = 0; i < metricToSendCount; ++i)
{
Assert.AreEqual($"test{i}:1|c|#KEY:VALUE", metricsReceived[i]);
}
}
}
}
public static IServiceCollection AddStatsD(this IServiceCollection services, IHostingEnvironment environment)
{
var cfg = new StatsdConfig {
Prefix = "modix"
};
if (!environment.IsProduction() && string.IsNullOrWhiteSpace(cfg.StatsdServerName))
{
services.AddSingleton <IDogStatsd, DebugDogStatsd>();
return(services);
}
DogStatsd.Configure(cfg);
services.AddSingleton(cfg);
services.AddSingleton <IDogStatsd>(provider =>
{
var config = provider.GetRequiredService <StatsdConfig>();
var service = new DogStatsdService();
service.Configure(config);
return(service);
});
return(services);
}
