public void LinkTo(ITargetBlock <string> target, CancellationToken cancellationToken)
{
_cancellationToken = cancellationToken;
Task.Factory.StartNew(() =>
{
try
{
var endpoint = new IPEndPoint(IPAddress.Any, _port);
var udpClient = new UdpClient(endpoint);
while (true)
{
if (_cancellationToken.IsCancellationRequested)
{
return;
}
byte[] data = udpClient.Receive(ref endpoint);
_systemMetrics.LogCount("listeners.udp.bytes", data.Length);
string rawPacket = Encoding.UTF8.GetString(data);
string[] lines = rawPacket.Replace("\r", "").Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (int index = 0; index < lines.Length; index++)
{
target.Post(lines[index]);
}
_systemMetrics.LogCount("listeners.udp.lines", lines.Length);
}
}
catch (ObjectDisposedException) { /* Eat it, socket was closed */ }
finally { IsListening = false; }
},
cancellationToken);
IsListening = true;
}
private void LoadListeners(StatsdnetConfiguration config, ISystemMetricsService systemMetrics)
{
// Load listeners - done last and once the rest of the chain is in place
foreach (var listenerConfig in config.Listeners)
{
if (listenerConfig is UDPListenerConfiguration)
{
var udpConfig = listenerConfig as UDPListenerConfiguration;
AddListener(new UdpStatsListener(udpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.udp." + udpConfig.Port);
}
else if (listenerConfig is TCPListenerConfiguration)
{
var tcpConfig = listenerConfig as TCPListenerConfiguration;
AddListener(new TcpStatsListener(tcpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.tcp." + tcpConfig.Port);
}
else if (listenerConfig is HTTPListenerConfiguration)
{
var httpConfig = listenerConfig as HTTPListenerConfiguration;
AddListener(new HttpStatsListener(httpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.http." + httpConfig.Port);
}
else if (listenerConfig is StatsdnetListenerConfiguration)
{
var statsdnetConfig = listenerConfig as StatsdnetListenerConfiguration;
AddListener(new StatsdnetTcpListener(statsdnetConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.statsdnet." + statsdnetConfig.Port);
}
}
}
public void Send(StatsdMessage[] lines)
{
string[] rawLines = lines.Select(p => p.ToString()).ToArray();
byte[] payload = Encoding.UTF8.GetBytes(String.Join(Environment.NewLine, rawLines));
_client.Send(payload, payload.Length);
_systemMetrics.LogCount("sent.bytes", payload.Length);
_systemMetrics.LogCount("sent.lines", payload.Length);
}
private void InitialiseRetryHandling()
{
_retryPolicy = Policy.Handle <SqlException>()
.WaitAndRetry(_retries, retryAttempt => TimeSpan.FromSeconds(1), (exception, timeSpan) =>
{
_log.WarnException(
string.Format("Retry failed. Trying again. Delay {1}, Error: {2}", timeSpan, exception.Message), exception);
_systemMetrics.LogCount("backends.sqlserver.retry");
});
}
private void InitialiseRetryHandling()
{
_retryStrategy = new Incremental(_retries, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2));
_retryPolicy = new RetryPolicy <SqlServerErrorDetectionStrategy>(_retries);
_retryPolicy.Retrying += (sender, args) =>
{
_log.Warn(String.Format("Retry {0} failed. Trying again. Delay {1}, Error: {2}", args.CurrentRetryCount, args.Delay, args.LastException.Message), args.LastException);
_systemMetrics.LogCount("backends.sqlserver.retry");
};
}
private void PostToLibrato(LibratoMetric[] lines)
{
try
{
PostToLibratoInternal(lines);
}
catch (Exception ex)
{
_log.ErrorException("Failed to post metrics to Librato.com", ex);
_systemMetrics.LogCount("backends.librato.post.error." + ex.GetType().Name);
}
}
private void ProcessIncomingConnection(TcpClient tcpClient)
{
try
{
Interlocked.Increment(ref _activeConnections);
_systemMetrics.LogGauge("listeners.statsdnet.activeConnections", _activeConnections);
_systemMetrics.LogCount("listeners.statsdnet.connection.open");
using (BinaryReader reader = new BinaryReader(tcpClient.GetStream()))
{
while (true)
{
if (reader.PeekChar() == 0)
{
// close the socket
return;
}
// Get the length
var packetLength = reader.ReadInt32();
// Is it compressed?
var isCompressed = reader.ReadBoolean();
// Now get the packet
var packet = reader.ReadBytes(packetLength);
// Decode
_decoderBlock.Post(new DecoderBlockPacket(packet, isCompressed));
}
}
}
catch (SocketException se)
{
// oops, we're done
_systemMetrics.LogCount("listeners.statsdnet.error.SocketException." + se.SocketErrorCode.ToString());
_log.Error(String.Format("Socket Error occurred while listening. Code: {0}", se.SocketErrorCode), se);
}
catch (Exception ex)
{
_systemMetrics.LogCount("listeners.statsdnet.error." + ex.GetType().Name);
_log.Error(String.Format("{0} Error occurred while listening: ", ex.GetType().Name, ex.Message),
ex);
}
finally
{
try
{
tcpClient.Close();
}
catch
{
// Do nothing but log that this happened
_systemMetrics.LogCount("listeners.statsdnet.error.closeThrewException");
}
_systemMetrics.LogCount("listeners.statsdnet.connection.closed");
Interlocked.Decrement(ref _activeConnections);
_systemMetrics.LogGauge("listeners.statsdnet.activeConnections", _activeConnections);
}
}
private void SendLine(GraphiteLine line)
{
byte[] data = Encoding.ASCII.GetBytes(line.ToString());
try
{
_client.Send(data, data.Length);
_systemMetrics.LogCount("backends.graphite.lines");
_systemMetrics.LogCount("backends.graphite.bytes", data.Length);
}
catch (SocketException ex)
{
_log.Error("Failed to send packet to Graphite: " + ex.SocketErrorCode);
}
}
private void ProcessIncomingConnection(TcpClient tcpClient)
{
try
{
Interlocked.Increment(ref _activeConnections);
_systemMetrics.LogGauge("tcp.activeConnections", _activeConnections);
_systemMetrics.LogCount("tcp.connection.open");
using (var networkStream = tcpClient.GetStream())
{
// Set an aggressive read timeout
networkStream.ReadTimeout = 1000; /* one second */
var buffer = new byte[4096];
while (!_token.IsCancellationRequested)
{
var byteCount = networkStream.Read(buffer, 0, buffer.Length);
if (byteCount == 0)
{
return;
}
_systemMetrics.LogCount("tcp.reads");
_systemMetrics.LogCount("tcp.bytes", byteCount);
var lines = Encoding.UTF8.GetString(buffer, 0, byteCount).Replace("\r", "").Split('\n');
// Post what we have
_systemMetrics.LogCount("tcp.lines", lines.Length);
lines.Where(p => !String.IsNullOrEmpty(p)).PostManyTo(_target);
// Two blank lines means end the connection
if (lines.Length >= 2 && lines[lines.Length - 2] == "" && lines[lines.Length - 1] == "")
{
return;
}
}
}
}
catch (SocketException se)
{
// oops, we're done
_systemMetrics.LogCount("tcp.error.SocketException." + se.SocketErrorCode.ToString());
}
catch (IOException)
{
// Not much we can do here.
_systemMetrics.LogCount("tcp.error.IOException");
}
finally
{
try
{
tcpClient.Close();
}
catch
{
// Do nothing but log that this happened
_systemMetrics.LogCount("tcp.error.closeThrewException");
}
_systemMetrics.LogCount("tcp.connection.closed");
Interlocked.Decrement(ref _activeConnections);
_systemMetrics.LogGauge("tcp.activeConnections", _activeConnections);
}
}
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, GraphiteLine messageValue, ISourceBlock <GraphiteLine> source, bool consumeToAccept)
{
byte[] data = Encoding.ASCII.GetBytes(messageValue.ToString());
try
{
_client.Send(data, data.Length);
_systemMetrics.LogCount("backends.graphite.lines");
_systemMetrics.LogCount("backends.graphite.bytes", data.Length);
}
catch (SocketException ex)
{
_log.Error("Failed to send packet to Graphite: " + ex.SocketErrorCode.ToString());
}
return(DataflowMessageStatus.Accepted);
}
public MSSQLRelayListener(string connectionString,
TimeSpan pollInterval,
CancellationToken cancellationToken,
int batchSize,
bool deleteAfterSend,
ISystemMetricsService metrics)
{
_connectionString = connectionString;
_intervalService = new IntervalService(pollInterval, cancellationToken);
_cancellationToken = cancellationToken;
_batchSize = batchSize;
_deleteAfterSend = deleteAfterSend;
_metrics = metrics;
var stopwatch = new Stopwatch();
_intervalService.Elapsed += (sender, e) =>
{
if (IsListening)
{
_intervalService.Cancel(true);
stopwatch.Restart();
ReadAndFeed();
stopwatch.Stop();
metrics.LogCount("listeners.mssql-relay.feedTimeSeconds", Convert.ToInt32(stopwatch.Elapsed.TotalSeconds));
// Only continue the interval service if cancellation
// isn't in progress
if (!cancellationToken.IsCancellationRequested)
{
_intervalService.Start();
}
}
};
}
private void AddAggregator(MessageType targetType,
ActionBlock <StatsdMessage> aggregator,
ISystemMetricsService systemMetrics)
{
_router.AddTarget(targetType, aggregator);
systemMetrics.LogCount("startup.aggregator." + targetType.ToString());
}
public MSSQLRelayListener(string connectionString,
TimeSpan pollInterval,
CancellationToken cancellationToken,
int batchSize,
bool deleteAfterSend,
ISystemMetricsService metrics)
{
_connectionString = connectionString;
_intervalService = new IntervalService(pollInterval, cancellationToken);
_cancellationToken = cancellationToken;
_batchSize = batchSize;
_deleteAfterSend = deleteAfterSend;
_metrics = metrics;
var stopwatch = new Stopwatch();
_intervalService.Elapsed += (sender, e) =>
{
if (IsListening)
{
_intervalService.Cancel(true);
stopwatch.Restart();
ReadAndFeed();
stopwatch.Stop();
metrics.LogCount("listeners.mssql-relay.feedTimeSeconds", Convert.ToInt32(stopwatch.Elapsed.TotalSeconds));
// Only continue the interval service if cancellation
// isn't in progress
if (!cancellationToken.IsCancellationRequested)
{
_intervalService.Start();
}
}
};
}
private void ProcessRequest(HttpListenerContext context)
{
context.Response.Headers.Add("Server", "statsd.net");
System.Threading.Thread.Sleep(10000);
if (context.Request.Url.PathAndQuery.Equals("/crossdomain.xml", StringComparison.OrdinalIgnoreCase))
{
SendCrossdomainFile(context.Response);
return;
}
else if (context.Request.Url.PathAndQuery.Equals("/favicon.ico", StringComparison.OrdinalIgnoreCase))
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.Close();
return;
}
else if (context.Request.HttpMethod.ToUpper() != "POST")
{
context.Response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
context.Response.StatusDescription = "Please use POST.";
context.Response.Close();
return;
}
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
// Get the body of this request
using (var body = context.Request.InputStream)
{
using (var reader = new System.IO.StreamReader(body, context.Request.ContentEncoding))
{
var rawPacket = reader.ReadToEnd();
_systemMetrics.LogCount("listeners.http.bytes", (int)context.Request.ContentLength64);
string[] lines = rawPacket.Replace("\r", "").Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (int index = 0; index < lines.Length; index++)
{
_target.Post(lines[index]);
}
_systemMetrics.LogCount("listeners.http.lines", lines.Length);
}
}
context.Response.Close();
}
private void LoadListeners(StatsdnetConfiguration config,
CancellationToken cancellationToken,
ISystemMetricsService systemMetrics)
{
// Load listeners - done last and once the rest of the chain is in place
foreach (var listenerConfig in config.Listeners)
{
if (listenerConfig is UDPListenerConfiguration)
{
var udpConfig = listenerConfig as UDPListenerConfiguration;
AddListener(new UdpStatsListener(udpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.udp." + udpConfig.Port);
}
else if (listenerConfig is TCPListenerConfiguration)
{
var tcpConfig = listenerConfig as TCPListenerConfiguration;
AddListener(new TcpStatsListener(tcpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.tcp." + tcpConfig.Port);
}
else if (listenerConfig is HTTPListenerConfiguration)
{
var httpConfig = listenerConfig as HTTPListenerConfiguration;
AddListener(new HttpStatsListener(httpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.http." + httpConfig.Port);
}
else if (listenerConfig is StatsdnetListenerConfiguration)
{
var statsdnetConfig = listenerConfig as StatsdnetListenerConfiguration;
AddListener(new StatsdnetTcpListener(statsdnetConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.statsdnet." + statsdnetConfig.Port);
}
else if (listenerConfig is MSSQLRelayListenerConfiguration)
{
var mssqlRelayConfig = listenerConfig as MSSQLRelayListenerConfiguration;
AddListener(new MSSQLRelayListener(mssqlRelayConfig.ConnectionString,
mssqlRelayConfig.PollInterval,
cancellationToken,
mssqlRelayConfig.BatchSize,
mssqlRelayConfig.DeleteAfterSend,
systemMetrics));
}
}
}
private void ProcessIncomingConnection(TcpClient tcpClient)
{
try
{
Interlocked.Increment(ref _activeConnections);
_systemMetrics.LogGauge("tcp.activeConnections", _activeConnections);
_systemMetrics.LogCount("tcp.connection.open");
using (var networkStream = tcpClient.GetStream())
{
var buffer = new byte[4096];
while (!_token.IsCancellationRequested)
{
var byteCount = networkStream.Read(buffer, 0, buffer.Length);
_systemMetrics.LogCount("tcp.bytes", byteCount);
var lines = Encoding.UTF8.GetString(buffer, 0, byteCount).Replace("\r", "").Split('\n');
// Post what we have
_systemMetrics.LogCount("tcp.lines", lines.Length);
lines.Where(p => !String.IsNullOrEmpty(p)).PostManyTo(_target);
// Two blank lines means end the connection
if (lines.Length >= 2 && lines[lines.Length - 2] == "" && lines[lines.Length - 1] == "")
{
return;
}
}
}
}
catch (SocketException)
{
// oops, we're done
}
catch (IOException)
{
// Not much we can do here.
}
finally
{
tcpClient.Close();
_systemMetrics.LogCount("tcp.connection.closed");
Interlocked.Increment(ref _activeConnections);
_systemMetrics.LogGauge("tcp.activeConnections", _activeConnections);
}
}
public UdpStatsListener(int port, ISystemMetricsService systemMetrics)
{
_port = port;
_systemMetrics = systemMetrics;
_preprocessorBlock = new ActionBlock<byte []>( (data) =>
{
// Log a metric to see what the difference between the read buffer and the max buffer size is
_systemMetrics.LogGauge("listeners.udp.buffer.max", MAX_BUFFER_SIZE);
_systemMetrics.LogGauge("listeners.udp.buffer.current", data.Length);
_systemMetrics.LogCount( "listeners.udp.bytes", data.Length );
string rawPacket = Encoding.UTF8.GetString( data );
string [] lines = rawPacket.Replace( "\r", "" ).Split( new char [] { '\n' }, StringSplitOptions.RemoveEmptyEntries );
for ( int index = 0; index < lines.Length; index++ )
{
_targetBlock.Post( lines [ index ] );
}
_systemMetrics.LogCount( "listeners.udp.lines", lines.Length );
}, Utility.UnboundedExecution() );
}
public UdpStatsListener(int port, ISystemMetricsService systemMetrics)
{
_port = port;
_systemMetrics = systemMetrics;
_preprocessorBlock = new ActionBlock <byte []>((data) =>
{
// Log a metric to see what the difference between the read buffer and the max buffer size is
_systemMetrics.LogGauge("listeners.udp.buffer.max", MAX_BUFFER_SIZE);
_systemMetrics.LogGauge("listeners.udp.buffer.current", data.Length);
_systemMetrics.LogCount("listeners.udp.bytes", data.Length);
string rawPacket = Encoding.UTF8.GetString(data);
string [] lines = rawPacket.Replace("\r", "").Split(new char [] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (int index = 0; index < lines.Length; index++)
{
_targetBlock.Post(lines [index]);
}
_systemMetrics.LogCount("listeners.udp.lines", lines.Length);
}, Utility.UnboundedExecution());
}
public void AddBackend(IBackend backend, ISystemMetricsService systemMetrics, string name)
{
_log.InfoFormat("Adding backend {0} named '{1}'", backend.GetType().Name, name);
_backends.Add(backend);
_messageBroadcaster.LinkTo(backend);
backend.Completion.LogAndContinueWith(name, () =>
{
if (_backends.All(q => !q.IsActive))
{
_shutdownComplete.Set();
}
});
systemMetrics.LogCount("startup.backend." + name);
}
public static TransformBlock<String, StatsdMessage> CreateMessageParserBlock(CancellationToken cancellationToken,
ISystemMetricsService systemMetrics,
ILog log)
{
var block = new TransformBlock<String, StatsdMessage>(
(line) =>
{
systemMetrics.LogCount("parser.linesSeen");
StatsdMessage message = StatsdMessageFactory.ParseMessage(line);
if (message is InvalidMessage)
{
systemMetrics.LogCount("parser.badLinesSeen");
log.Info("Bad message: " + ((InvalidMessage)message).Reason);
}
return message;
},
new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = ExecutionDataflowBlockOptions.Unbounded,
CancellationToken = cancellationToken
});
return block;
}
public static TransformBlock <String, StatsdMessage> CreateMessageParserBlock(CancellationToken cancellationToken,
ISystemMetricsService systemMetrics)
{
var block = new TransformBlock <String, StatsdMessage>(
(line) =>
{
systemMetrics.LogCount("parser.linesSeen");
StatsdMessage message = StatsdMessageFactory.ParseMessage(line);
if (message is InvalidMessage)
{
systemMetrics.LogCount("parser.badLinesSeen");
log.Info("Bad message: " + ((InvalidMessage)message).Reason + Environment.NewLine + line);
}
return(message);
},
new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = ExecutionDataflowBlockOptions.Unbounded,
CancellationToken = cancellationToken
});
return(block);
}
private void PostMetrics(GraphiteLine[][] lineArrays)
{
var lines = new List <GraphiteLine>();
foreach (var graphiteLineArray in lineArrays)
{
lines.AddRange(graphiteLineArray);
}
var rawText = string.Join(Environment.NewLine,
lines.Select(line => line.ToString()).ToArray());
var bytes = Encoding.UTF8.GetBytes(rawText);
if (_client.Send(bytes))
{
_systemMetrics.LogCount("backends.statsdnet.lines", lines.Count);
_systemMetrics.LogGauge("backends.statsdnet.bytes", bytes.Length);
}
}
public void Configure(string collectorName, XElement configElement, ISystemMetricsService systemMetrics)
{
_completionTask = new Task(() => IsActive = false);
_systemMetrics = systemMetrics;
var config = new LibratoBackendConfiguration(
email: configElement.Attribute("email").Value,
token: configElement.Attribute("token").Value,
numRetries: configElement.ToInt("numRetries"),
retryDelay: Utility.ConvertToTimespan(configElement.Attribute("retryDelay").Value),
postTimeout: Utility.ConvertToTimespan(configElement.Attribute("postTimeout").Value),
maxBatchSize: configElement.ToInt("maxBatchSize"),
countersAsGauges: configElement.ToBoolean("countersAsGauges")
);
_config = config;
_source = collectorName;
_serviceVersion = Assembly.GetEntryAssembly().GetName().Version.ToString();
_preprocessorBlock = new ActionBlock <Bucket>(bucket => ProcessBucket(bucket), Utility.UnboundedExecution());
_batchBlock = new BatchBlock <LibratoMetric>(_config.MaxBatchSize);
_outputBlock = new ActionBlock <LibratoMetric[]>(lines => PostToLibrato(lines), Utility.OneAtATimeExecution());
_batchBlock.LinkTo(_outputBlock);
_client = new HttpClient()
{
BaseAddress = new Uri(LIBRATO_API_URL)
};
var authByteArray = Encoding.ASCII.GetBytes(string.Format("{0}:{1}", _config.Email, _config.Token));
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authByteArray));
_client.Timeout = TimeSpan.FromMilliseconds(_config.PostTimeout.TotalMilliseconds);
_retryPolicy = Policy.Handle <TimeoutException>().WaitAndRetry(_config.NumRetries, retryAttempt => _config.RetryDelay, (exception, timeSpan) =>
{
_log.WarnException(String.Format("Retry failed. Trying again. Delay {1}, Error: {2}", timeSpan, exception.Message), exception);
_systemMetrics.LogCount("backends.librato.retry");
});
IsActive = true;
}
public void Configure(string collectorName, XElement configElement, ISystemMetricsService systemMetrics)
{
_completionTask = new Task(() => IsActive = false);
_log = SuperCheapIOC.Resolve <ILog>();
_systemMetrics = systemMetrics;
var config = new LibratoBackendConfiguration(
email: configElement.Attribute("email").Value,
token: configElement.Attribute("token").Value,
numRetries: configElement.ToInt("numRetries"),
retryDelay: Utility.ConvertToTimespan(configElement.Attribute("retryDelay").Value),
postTimeout: Utility.ConvertToTimespan(configElement.Attribute("postTimeout").Value),
maxBatchSize: configElement.ToInt("maxBatchSize"),
countersAsGauges: configElement.ToBoolean("countersAsGauges")
);
_config = config;
_source = collectorName;
_serviceVersion = Assembly.GetEntryAssembly().GetName().Version.ToString();
_preprocessorBlock = new ActionBlock <Bucket>(bucket => ProcessBucket(bucket), Utility.UnboundedExecution());
_batchBlock = new BatchBlock <LibratoMetric>(_config.MaxBatchSize);
_outputBlock = new ActionBlock <LibratoMetric[]>(lines => PostToLibrato(lines), Utility.OneAtATimeExecution());
_batchBlock.LinkTo(_outputBlock);
_client = new RestClient(LIBRATO_API_URL);
_client.Authenticator = new HttpBasicAuthenticator(_config.Email, _config.Token);
_client.Timeout = (int)_config.PostTimeout.TotalMilliseconds;
_retryPolicy = new RetryPolicy <LibratoErrorDetectionStrategy>(_config.NumRetries);
_retryPolicy.Retrying += (sender, args) =>
{
_log.Warn(String.Format("Retry {0} failed. Trying again. Delay {1}, Error: {2}", args.CurrentRetryCount, args.Delay, args.LastException.Message), args.LastException);
_systemMetrics.LogCount("backends.librato.retry");
};
_retryStrategy = new Incremental(_config.NumRetries, _config.RetryDelay, TimeSpan.FromSeconds(2));
IsActive = true;
}
private void SendBatch(GraphiteLine[] batch)
{
try
{
_systemMetrics.LogCount("backends.graphite-tcp.write.attempt");
EnsureConnectedClient(ref _client);
var lines = batch.Select(p => p.ToString()).ToArray();
var payload = string.Join(Environment.NewLine, lines) + Environment.NewLine;
var bytes = Encoding.UTF8.GetBytes(payload);
_systemMetrics.LogCount("backends.graphite-tcp.lines", lines.Length);
_systemMetrics.LogCount("backends.graphite-tcp.bytes", bytes.Length);
_client.GetStream().Write(bytes, 0, bytes.Length);
_systemMetrics.LogCount("backends.graphite-tcp.write.success");
}
catch (Exception ex)
{
_log.ErrorException(string.Format("Could not write batch to graphite host at {0}:{1}", _host, _port), ex);
_systemMetrics.LogCount("backends.graphite-tcp.write.failure");
_systemMetrics.LogCount("backends.graphite-tcp.write.exception." + ex.GetType().Name);
}
}
private bool Send(byte[] data, int retryAttemptsLeft)
{
/** Statsd.net packet format consists of
* byte 0: 32-bit integer length
* byte 33: boolean for whether the data is compressed or not
* byte 34-: the packet
*/
if (data.Length == 0)
{
return(true);
}
Func <bool> handleRetry = () =>
{
_systemMetrics.LogCount("backends.statsdnet.sendFailed");
if (retryAttemptsLeft > 0)
{
_systemMetrics.LogCount("backends.statsdnet.retrySend");
return(Send(data, --retryAttemptsLeft));
}
else
{
_systemMetrics.LogCount("backends.statsdnet.retrySendFailed");
return(false);
}
};
try
{
if (!_client.Connected)
{
try
{
_client.Close();
}
catch (Exception)
{
// eat it
}
_client = new TcpClient();
_client.Connect(_host, _port);
_writer = new BinaryWriter(_client.GetStream());
}
if (_enableCompression && data.Length < COMPRESSION_SIZE_THRESHOLD)
{
_writer.Write(data.Length);
_writer.Write(false);
_writer.Write(data);
_systemMetrics.LogCount("backends.statsdnet.bytes.raw", data.Length);
_systemMetrics.LogCount("backends.statsdnet.bytes.compressed", data.Length);
}
else
{
var compressedData = data.Compress();
_writer.Write(compressedData.Length);
_writer.Write(true);
_writer.Write(compressedData);
_systemMetrics.LogCount("backends.statsdnet.bytes.raw", data.Length);
_systemMetrics.LogCount("backends.statsdnet.bytes.compressed", compressedData.Length);
}
return(true);
}
catch (SocketException se)
{
_systemMetrics.LogCount("backends.statsdnet.error.SocketException." + se.SocketErrorCode.ToString());
_log.Error(String.Format("Socket Error occurred while listening. Code: {0}", se.SocketErrorCode), se);
return(handleRetry());
}
catch (Exception ex)
{
_systemMetrics.LogCount("backends.statsdnet.error." + ex.GetType().Name);
_log.Error(String.Format("{0} Error occurred while listening: ", ex.GetType().Name, ex.Message),
ex);
if (ex is IOException)
{
return(handleRetry());
}
else
{
return(false);
}
}
}
private void ReadAndFeed()
{
try
{
_metrics.LogCount("listeners.mssql-relay.feed.attempt");
var lines = GetNewLinesFromDB();
foreach (String line in lines)
{
var parts = line.Split(SPACE_SPLITTER, StringSplitOptions.RemoveEmptyEntries);
_target.Post(parts[0] + ":" + parts[1] + "|r|" + parts[2]);
}
_metrics.LogCount("listeners.mssql-relay.lines.posted" + lines.Count);
_metrics.LogCount("listeners.mssql-relay.feed.success");
}
catch (Exception ex)
{
_metrics.LogCount("listeners.mssql-relay.error." + ex.GetType().Name);
_metrics.LogCount("listeners.mssql-relay.feed.failure");
}
}
public void Configure(string collectorName, XElement configElement, ISystemMetricsService systemMetrics)
{
_completionTask = new Task(() => IsActive = false);
_log = SuperCheapIOC.Resolve<ILog>();
_systemMetrics = systemMetrics;
var config = new LibratoBackendConfiguration(
email: configElement.Attribute("email").Value,
token: configElement.Attribute("token").Value,
numRetries: configElement.ToInt("numRetries"),
retryDelay: Utility.ConvertToTimespan(configElement.Attribute("retryDelay").Value),
postTimeout: Utility.ConvertToTimespan(configElement.Attribute("postTimeout").Value),
maxBatchSize: configElement.ToInt("maxBatchSize"),
countersAsGauges: configElement.ToBoolean("countersAsGauges")
);
_config = config;
_source = collectorName;
_serviceVersion = Assembly.GetEntryAssembly().GetName().Version.ToString();
_preprocessorBlock = new ActionBlock<Bucket>(bucket => ProcessBucket(bucket), Utility.UnboundedExecution());
_batchBlock = new BatchBlock<LibratoMetric>(_config.MaxBatchSize);
_outputBlock = new ActionBlock<LibratoMetric[]>(lines => PostToLibrato(lines), Utility.OneAtATimeExecution());
_batchBlock.LinkTo(_outputBlock);
_client = new RestClient(LIBRATO_API_URL);
_client.Authenticator = new HttpBasicAuthenticator(_config.Email, _config.Token);
_client.Timeout = (int)_config.PostTimeout.TotalMilliseconds;
_retryPolicy = new RetryPolicy<LibratoErrorDetectionStrategy>(_config.NumRetries);
_retryPolicy.Retrying += (sender, args) =>
{
_log.Warn(String.Format("Retry {0} failed. Trying again. Delay {1}, Error: {2}", args.CurrentRetryCount, args.Delay, args.LastException.Message), args.LastException);
_systemMetrics.LogCount("backends.librato.retry");
};
_retryStrategy = new Incremental(_config.NumRetries, _config.RetryDelay, TimeSpan.FromSeconds(2));
IsActive = true;
}
public void AddBackend(IBackend backend, ISystemMetricsService systemMetrics, string name)
{
_log.InfoFormat("Adding backend {0} named '{1}'", backend.GetType().Name, name);
_backends.Add(backend);
_messageBroadcaster.LinkTo(backend);
backend.Completion.LogAndContinueWith(_log, name, () =>
{
if (_backends.All(q => !q.IsActive))
{
_shutdownComplete.Set();
}
});
systemMetrics.LogCount("startup.backend." + name);
}
private void AddAggregator(MessageType targetType,
ActionBlock<StatsdMessage> aggregator,
ISystemMetricsService systemMetrics)
{
_router.AddTarget(targetType, aggregator);
systemMetrics.LogCount("startup.aggregator." + targetType.ToString());
}
private void LoadListeners(StatsdnetConfiguration config,
CancellationToken cancellationToken,
ISystemMetricsService systemMetrics)
{
// Load listeners - done last and once the rest of the chain is in place
foreach (var listenerConfig in config.Listeners)
{
if (listenerConfig is UDPListenerConfiguration)
{
var udpConfig = listenerConfig as UDPListenerConfiguration;
AddListener(new UdpStatsListener(udpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.udp." + udpConfig.Port);
}
else if (listenerConfig is TCPListenerConfiguration)
{
var tcpConfig = listenerConfig as TCPListenerConfiguration;
AddListener(new TcpStatsListener(tcpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.tcp." + tcpConfig.Port);
}
else if (listenerConfig is HTTPListenerConfiguration)
{
var httpConfig = listenerConfig as HTTPListenerConfiguration;
AddListener(new HttpStatsListener(httpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.http." + httpConfig.Port);
}
else if (listenerConfig is StatsdnetListenerConfiguration)
{
var statsdnetConfig = listenerConfig as StatsdnetListenerConfiguration;
AddListener(new StatsdnetTcpListener(statsdnetConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.statsdnet." + statsdnetConfig.Port);
}
else if (listenerConfig is MSSQLRelayListenerConfiguration)
{
var mssqlRelayConfig = listenerConfig as MSSQLRelayListenerConfiguration;
AddListener(new MSSQLRelayListener(mssqlRelayConfig.ConnectionString,
mssqlRelayConfig.PollInterval,
cancellationToken,
mssqlRelayConfig.BatchSize,
mssqlRelayConfig.DeleteAfterSend,
systemMetrics));
}
}
}
private void LoadListeners(StatsdnetConfiguration config, ISystemMetricsService systemMetrics)
{
// Load listeners - done last and once the rest of the chain is in place
foreach (var listenerConfig in config.Listeners)
{
if (listenerConfig is UDPListenerConfiguration)
{
var udpConfig = listenerConfig as UDPListenerConfiguration;
AddListener(new UdpStatsListener(udpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.udp." + udpConfig.Port);
}
else if (listenerConfig is TCPListenerConfiguration)
{
var tcpConfig = listenerConfig as TCPListenerConfiguration;
AddListener(new TcpStatsListener(tcpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.tcp." + tcpConfig.Port);
}
else if (listenerConfig is HTTPListenerConfiguration)
{
var httpConfig = listenerConfig as HTTPListenerConfiguration;
AddListener(new HttpStatsListener(httpConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.http." + httpConfig.Port);
}
else if (listenerConfig is StatsdnetListenerConfiguration)
{
var statsdnetConfig = listenerConfig as StatsdnetListenerConfiguration;
AddListener(new StatsdnetTcpListener(statsdnetConfig.Port, systemMetrics));
systemMetrics.LogCount("startup.listener.statsdnet." + statsdnetConfig.Port);
}
}
}