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();
}
}
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();
}
}
/// <summary>
/// Configures ApplicationInsights for telemetry.
/// </summary>
private void SetupAppInsights()
{
if (!string.IsNullOrEmpty(this.Config.InstrumentationKey))
{
var telemetryConfig = new TelemetryConfiguration
{
InstrumentationKey = this.Config.InstrumentationKey,
};
telemetryConfig.TelemetryChannel.DeveloperMode = this.Config.IsDevMode;
this.AppInsights = new TelemetryClient(telemetryConfig);
this.AppInsights.Context.GlobalProperties.Add("Shard", this.Shard.ToString());
this.AppInsights.Context.GlobalProperties.Add("BotType", this.BotType.ToString());
this.AppInsights.Context.GlobalProperties.Add("Version", Assembly.GetEntryAssembly().GetName().Version.ToString());
}
var dogstatsdConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1"
};
this.DogStats = new DogStatsdService();
this.DogStats.Configure(dogstatsdConfig);
}
public DatadogTelemetryConsumer()
{
var config = new StatsdConfig();
_service = new DogStatsdService();
_service.Configure(config);
}
public void Throw_exception_when_no_config_provided()
{
var sut = CreateSut();
StatsdConfig metricsConfig = null;
Assert.Throws <ArgumentNullException>(() => sut.Configure(metricsConfig));
}
private IPEndPoint GetUDPIPEndPoint(StatsdConfig config)
{
BuildStatsData(config);
Assert.NotNull(_ipEndPoint);
return(_ipEndPoint);
}
public void CreateTelemetry()
{
Environment.SetEnvironmentVariable(StatsdConfig.EntityIdEnvVar, "EntityId");
Environment.SetEnvironmentVariable(StatsdConfig.ServiceEnvVar, "service");
Environment.SetEnvironmentVariable(StatsdConfig.EnvironmentEnvVar, "env");
Environment.SetEnvironmentVariable(StatsdConfig.VersionEnvVar, "version");
var config = new StatsdConfig {
};
var conf = config.Advanced;
conf.TelemetryFlushInterval = TimeSpan.FromMinutes(1);
config.ConstantTags = new[] { "key:value" };
var expectedTags = new List <string>(config.ConstantTags);
expectedTags.Add("dd.internal.entity_id:EntityId");
expectedTags.Add($"{StatsdConfig.ServiceTagKey}:service");
expectedTags.Add($"{StatsdConfig.EnvironmentTagKey}:env");
expectedTags.Add($"{StatsdConfig.VersionTagKey}:version");
BuildStatsData(config);
_mock.Verify(m => m.CreateUDPTransport(It.IsAny <IPEndPoint>()), Times.Once);
_mock.Verify(
m => m.CreateTelemetry(
It.IsAny <MetricSerializer>(),
It.Is <string>(v => !string.IsNullOrEmpty(v)),
conf.TelemetryFlushInterval.Value,
It.IsAny <ITransport>(),
It.Is <string[]>(tags => Enumerable.SequenceEqual(tags, expectedTags))));
}
private string GetUDSStatsdServerName(StatsdConfig config)
{
BuildStatsData(config);
Assert.NotNull(_unixEndPoint);
return(_unixEndPoint.Filename);
}
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);
}
static DogStatsdService CreateService(
TemporaryPath temporaryPath,
HostnameProvider hostnameProvider = HostnameProvider.Property)
{
var serverName = StatsdUnixDomainSocket.UnixDomainSocketPrefix + temporaryPath.Path;
var dogstatsdConfig = new StatsdConfig {
StatsdMaxUnixDomainSocketPacketSize = 1000
};
switch (hostnameProvider)
{
case HostnameProvider.Property: dogstatsdConfig.StatsdServerName = serverName; break;
case HostnameProvider.Environment:
{
Environment.SetEnvironmentVariable(StatsdConfig.DD_AGENT_HOST_ENV_VAR, serverName);
break;
}
}
var dogStatsdService = new DogStatsdService();
dogStatsdService.Configure(dogstatsdConfig);
return(dogStatsdService);
}
public SocketServer(StatsdConfig config)
{
EndPoint endPoint;
int bufferSize;
var serverName = config.StatsdServerName;
if (serverName.StartsWith(StatsdBuilder.UnixDomainSocketPrefix))
{
serverName = serverName.Substring(StatsdBuilder.UnixDomainSocketPrefix.Length);
_server = new Socket(AddressFamily.Unix, SocketType.Dgram, ProtocolType.Unspecified);
if (!string.IsNullOrEmpty(serverName) && serverName == Path.GetFullPath(serverName))
{
File.Delete(serverName);
}
endPoint = new UnixEndPoint(serverName);
bufferSize = config.StatsdMaxUnixDomainSocketPacketSize;
}
else
{
endPoint = new IPEndPoint(IPAddress.Parse(config.StatsdServerName), config.StatsdPort);
_server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
bufferSize = config.StatsdMaxUDPPacketSize;
}
_server.ReceiveTimeout = 1000;
_server.Bind(endPoint);
Start(bufferSize);
}
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 SocketServer(StatsdConfig config, bool removeUDSFileBeforeStarting = false)
{
EndPoint endPoint;
int bufferSize;
var serverName = config.StatsdServerName;
if (serverName.StartsWith(StatsdBuilder.UnixDomainSocketPrefix))
{
serverName = serverName.Substring(StatsdBuilder.UnixDomainSocketPrefix.Length);
if (removeUDSFileBeforeStarting)
{
File.Delete(serverName);
}
_server = new Socket(AddressFamily.Unix, SocketType.Dgram, ProtocolType.Unspecified);
endPoint = new UnixEndPoint(serverName);
bufferSize = config.StatsdMaxUnixDomainSocketPacketSize;
}
else
{
endPoint = new IPEndPoint(IPAddress.Parse(config.StatsdServerName), config.StatsdPort);
_server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
bufferSize = config.StatsdMaxUDPPacketSize;
}
_server.ReceiveTimeout = 1000;
_server.Bind(endPoint);
_receiver = Task.Run(() => ReadFromServer(bufferSize));
}
public DataDogMetricsPublisher(IDogStatsd dogStatsdService, StatsdConfig config)
{
this.dogStatsdService = dogStatsdService ??
throw new ArgumentNullException(nameof(dogStatsdService));
dogStatsdService.Configure(config ??
throw new ArgumentNullException(nameof(config)));
}
public void Throw_exception_when_no_hostname_provided()
{
var sut = CreateSut();
var metricsConfig = new StatsdConfig {
};
Assert.Throws <ArgumentNullException>(() => sut.Configure(metricsConfig));
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(hostname: "127.0.0.1", port: 8126);
var metricsConfig = new StatsdConfig {
StatsdServerName = "127.0.0.1", StatsdPort = 8126
};
DogStatsd.Configure(metricsConfig);
}
public void SetUpUdpListener()
{
udpListener = new UdpListener(serverName, serverPort);
var metricsConfig = new StatsdConfig {
StatsdServerName = serverName, StatsdPort = serverPort
};
StatsdClient.DogStatsd.Configure(metricsConfig);
}
private static void ConfigureDogStatsd(StatsdConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
DogStatsd.Configure(config);
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(hostname: "127.0.0.1", port: 8126);
var metricsConfig = new StatsdConfig {
StatsdServerName = "127.0.0.1", StatsdPort = 8126
};
metricsConfig.Advanced.TelemetryFlushInterval = TimeSpan.FromDays(1);
DogStatsd.Configure(metricsConfig);
}
public void default_port_is_8251()
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1"
};
StatsdClient.CloudInsightStatsd.Configure(metricsConfig);
testReceive("127.0.0.1", 8251, "test", "test:1|c");
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(serverName, _serverPort);
var metricsConfig = new StatsdConfig {
StatsdServerName = serverName, StatsdPort = _serverPort
};
_dogStatsdService = new DogStatsdService();
_dogStatsdService.Configure(metricsConfig);
}
public void default_port_is_8125()
{
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1"
};
StatsdClient.GlobalStatsd.Instance.Configure(metricsConfig);
testReceive("127.0.0.1", 8125, "test", "test:1|c");
}
private static void ConfigureDataDog(string servername)
{
var dogstatsdConfig = new StatsdConfig
{
StatsdServerName = servername,
StatsdPort = 8125
};
DogStatsd.Configure(dogstatsdConfig);
}
public void UDPReconnection()
{
var config = new StatsdConfig
{
StatsdServerName = "127.0.0.1",
StatsdPort = 1234,
};
CheckReconnection(c => new SocketServer(c), config);
}
public static void Configure()
{
var metricsConfig = new StatsdConfig()
{
StatsdServerName = "127.0.0.1",
Prefix = "Reflux"
};
DogStatsd.Configure(metricsConfig);
}
public void NamedPipeReconnection()
{
var config = new StatsdConfig
{
PipeName = "TestPipe",
};
config.Advanced.TelemetryFlushInterval = null;
CheckReconnection(c => new NamedPipeServer(c.PipeName, 1000, TimeSpan.FromSeconds(1)), config);
}
public void default_port_is_8125()
{
var sut = CreateSut();
var metricsConfig = new StatsdConfig
{
StatsdServerName = "127.0.0.1"
};
sut.Configure(metricsConfig);
testReceive("127.0.0.1", 8125, "test", "test:1|c", sut);
}
public override void Install(Module m)
{
var dogstatsdConfig = new StatsdConfig
{
StatsdServerName = Global.Config.DatadogHost,
StatsdPort = 8125,
Prefix = "miki"
};
DogStatsd.Configure(dogstatsdConfig);
base.Install(m);
var eventSystem = m.EventSystem;
// TODO (Veld): reimplement this
//b.HttpClient.RestClient.OnRequestComplete += (method, uri) =>
//{
// DogStatsd.Histogram("discord.http.requests", 1, 1, new[]
// {
// $"http_method:{method}", $"http_uri:{uri}"
// });
//};
if (eventSystem != null)
{
var defaultHandler = eventSystem.GetCommandHandler <SimpleCommandHandler>();
if (defaultHandler != null)
{
defaultHandler.OnMessageProcessed += (command, message, time) =>
{
if (command.Module == null)
{
return(Task.CompletedTask);
}
DogStatsd.Histogram("commands.time", time, 0.1, new[] {
$"commandtype:{command.Module.Name.ToLowerInvariant()}",
$"commandname:{command.Name.ToLowerInvariant()}"
});
DogStatsd.Counter("commands.count", 1, 1, new[] {
$"commandtype:{command.Module.Name.ToLowerInvariant()}",
$"commandname:{command.Name.ToLowerInvariant()}"
});
return(Task.CompletedTask);
};
}
}
Log.Message("Datadog set up!");
}
public static void EnableDatadog(string statsdServerAddress, int statsdServerPort)
{
// always use udp port
var dogstatsdConfig = new StatsdConfig
{
StatsdServerName = statsdServerAddress,
StatsdPort = statsdServerPort,
};
DogStatsd.Configure(dogstatsdConfig);
}
private IPEndPoint GetUDPIPEndPoint(StatsdConfig config)
{
IPEndPoint endPoint = null;
_mock.Setup(m => m.CreateUDPStatsSender(It.IsAny <IPEndPoint>()))
.Callback <IPEndPoint>(e => endPoint = e);
BuildStatsData(config);
Assert.NotNull(endPoint);
return(endPoint);
}
