public ApiCollector(ILogger logger, Action <string, MessageLevels, string> notify, CommonCollectorServiceVariables settings)
{
_logger = logger;
_collectorHelper = new CollectorHelper(settings, _logger);
_notify = notify;
_settings = settings;
}
/// <summary>
/// Creates an instrumentation logger. It can perform both regular logging and FFD logging
/// </summary>
/// <param name="loggerName"></param>
/// <returns></returns>
public static IInstrumentedLogger CreateInstrumentedLogger(string loggerName)
{
ILogCollector collector;
try
{
collector = CollectorHelper.CreateCollectorForLogger(loggerName);
}
catch
{
collector = CollectorHelper.CreateCollector();
}
int heartbeatInterval = 0;
try
{
foreach (LoggerDefinition definition in ConfigurationHelper.SourceConfiguration.logger)
{
if (definition.name != loggerName)
{
continue;
}
heartbeatInterval = definition.heartbeatinterval;
break;
}
}
catch { }
return(new FieldFailureDataLogger(collector, loggerName)
{
HeartbeatInterval = heartbeatInterval
});
}
public async Task <bool> Start(CommonCollectorServiceVariables settings)
{
ServiceVariables = settings;
_collectorHelper = new CollectorHelper(settings, _logger);
ValidateFuncs();
return(await RunCollectionFlow().ConfigureAwait(false));
}
/// <summary>
/// Creates a logger with given facility and default collector
/// </summary>
/// <param name="facility">Syslog facility to use</param>
/// <returns></returns>
public static ILog GetLogger(SyslogFacility facility)
{
ILogger ret = InstantiateLogger();
ret.Collector = CollectorHelper.CreateCollector();
ret.Facility = facility;
return(ret);
}
public T4Runtime()
{
_collector = new CollectorForAssembly();
var a = Assembly.LoadFile(ResolveDLLPath(DLL_NAME));
CollectorHelper.AppendTypes(_collector, a);
}
static void Main(string[] args)
{
Console.CancelKeyPress += Console_CancelKeyPress;
if (args == null || args.Length < 1)
{
Console.WriteLine("Usage: NoiseSource ([MESSAGE_RATE]|\"inf\")");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("\tMESSAGE_RATE:\t number of messages sent per second");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Example: \tNoiseSource 1500");
Console.WriteLine("sends 1500 messages per second");
Console.WriteLine("\tNoiseSource inf");
Console.WriteLine("sends infinite messages, flooding network socket");
Environment.Exit(0);
}
int rate = 0;
if (args[0] != "inf" && !int.TryParse(args[0], out rate) || rate == 0)
{
Console.WriteLine("Invalid rate");
Environment.Exit(1);
}
long timeout = 10000000 / rate; //100ns timeout
if (timeout == 0)
{
Console.WriteLine("Ready to send infinite messages at infinite rate");
}
else
{
Console.WriteLine("Ready to send infinite messages at a rate of {0}/s", rate);
}
ILogCollector server = CollectorHelper.CreateCollector();
string host = System.Net.Dns.GetHostName();
while (true)
{
SyslogMessage startMsg = new SyslogMessage
{
Timestamp = DateTime.Now,
Facility = SyslogFacility.Printer,
Severity = SyslogSeverity.Debug,
Host = host,
MessageId = "NOISE",
Text = "The quick brown fox jumps over the lazy dog"
};
server.SubmitMessage(startMsg);
if (rate > 0)
{
Thread.Sleep(new TimeSpan(timeout));
}
}
}
public void CreateDefaultCollectorTest()
{
ILogCollector expected = null; // TODO: Eseguire l'inizializzazione a un valore appropriato
ILogCollector actual;
actual = CollectorHelper.CreateCollector();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verificare la correttezza del metodo di test.");
}
public void CreateUdpCollectorTest()
{
IPAddress logbus_ip = null; // TODO: Eseguire l'inizializzazione a un valore appropriato
int logbus_port = 0; // TODO: Eseguire l'inizializzazione a un valore appropriato
ILogCollector expected = null; // TODO: Eseguire l'inizializzazione a un valore appropriato
ILogCollector actual;
actual = CollectorHelper.CreateUnreliableCollector(logbus_ip, logbus_port);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verificare la correttezza del metodo di test.");
}
/// <summary>
/// Creates a logger by name
/// </summary>
/// <param name="loggerName">Name of logger</param>
/// <returns></returns>
public static ILog GetLogger(string loggerName)
{
if (_loggers.ContainsKey("loggerName"))
{
return(_loggers["loggerName"]);
}
ILog ret = InstantiateLogger(loggerName);
ret.Collector = CollectorHelper.CreateCollectorForLogger(loggerName);
return(ret);
}
/// <summary>
/// Creates a logger by name
/// </summary>
/// <param name="loggerName">Name of logger</param>
/// <param name="facility">Syslog facility to use</param>
/// <returns></returns>
public static ILog GetLogger(string loggerName, SyslogFacility facility)
{
if (_loggers.ContainsKey("loggerName"))
{
ILogger retu = (ILogger)_loggers["loggerName"].Clone();
retu.Facility = facility;
return(retu);
}
ILogger ret = InstantiateLogger(loggerName);
ret.Collector = CollectorHelper.CreateCollectorForLogger(loggerName);
ret.Facility = facility;
return(ret);
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via TLS, using default port
/// </summary>
/// <param name="logbusHost">IP address of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetReliableLogger(string logbusHost, SyslogFacility facility)
{
return(GetLogger(facility, CollectorHelper.CreateReliableCollector(logbusHost, SyslogTlsReceiver.TLS_PORT)));
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via TLS
/// </summary>
/// <param name="logbusHost">IP address of logbus target</param>
/// <param name="logbusPort">UDP port of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetReliableLogger(string logbusHost, int logbusPort, SyslogFacility facility)
{
return(GetLogger(facility, CollectorHelper.CreateReliableCollector(logbusHost, logbusPort)));
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via UDP, using default port
/// </summary>
/// <param name="logbusHost">IP address of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetUnreliableLogger(string logbusHost, SyslogFacility facility)
{
return(GetLogger(facility,
CollectorHelper.CreateUnreliableCollector(logbusHost, SyslogUdpReceiver.DEFAULT_PORT)));
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via UDP
/// </summary>
/// <param name="logbusIp">IP address of logbus target</param>
/// <param name="logbusPort">UDP port of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetUnreliableLogger(IPAddress logbusIp, int logbusPort, SyslogFacility facility)
{
return(GetLogger(facility, CollectorHelper.CreateUnreliableCollector(logbusIp, logbusPort)));
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via TLS
/// </summary>
/// <param name="logbusHost">IP address of logbus target</param>
/// <param name="logbusPort">TLS port of logbus target</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
/// <remarks>Facility is set to Local4 as default value</remarks>
public static ILog GetReliableLogger(string logbusHost, int logbusPort)
{
return(GetLogger(CollectorHelper.CreateReliableCollector(logbusHost, logbusPort)));
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via UDP, using default port
/// </summary>
/// <param name="logbusIp">IP address of logbus target</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
/// <remarks>Facility is set to Local4 as default value</remarks>
public static ILog GetUnreliableLogger(IPAddress logbusIp)
{
return(GetLogger(CollectorHelper.CreateUnreliableCollector(logbusIp, SyslogUdpReceiver.DEFAULT_PORT)));
}
private static void Run(int timeout)
{
_messagesRcvd = new BitArray(_expected, false);
_received = 0;
string pid = Process.GetCurrentProcess().Id.ToString(CultureInfo.InvariantCulture);
ILogCollector server = CollectorHelper.CreateCollector();
string host = Dns.GetHostName();
PropertyFilter hostFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value = host,
propertyName = Property.Host
};
FacilityEqualsFilter facFilter = new FacilityEqualsFilter {
facility = SyslogFacility.Local4
};
PropertyFilter pidFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value = pid,
propertyName = Property.ProcessID
};
PropertyFilter idFilter = new PropertyFilter
{
value = "BENCH",
comparison = ComparisonOperator.eq,
propertyName = Property.MessageID
};
SeverityFilter sevFilter = new SeverityFilter
{
comparison = ComparisonOperator.eq,
severity = SyslogSeverity.Notice
};
using (ILogClient client = ClientHelper.CreateReliableClient(hostFilter & pidFilter & idFilter & sevFilter & facFilter))
{
client.MessageReceived += client_MessageReceived;
client.Start();
for (int i = 0; i < _expected; i++)
{
if (timeout > 0)
{
Nanosleep(timeout);
}
SyslogMessage message = new SyslogMessage
{
Timestamp = DateTime.Now,
Facility = SyslogFacility.Local4,
Severity = SyslogSeverity.Notice,
Host = host,
ProcessID = pid,
MessageId = "BENCH",
Text = i.ToString()
};
server.SubmitMessage(message);
}
silenceTimer = new Timer(state => Stop.Set(), null, 40000, Timeout.Infinite);
Console.WriteLine("Waiting up to 30 seconds after last message received...");
Stop.WaitOne();
}
if (_expected == _received)
{
Console.WriteLine("Received all messaged");
}
else
{
Console.WriteLine("Lost {0} messages", _expected - _received);
}
}
/// <summary>
/// Creates a reliable FFD logger
/// </summary>
/// <param name="loggerName">Name of logger</param>
/// <param name="host">Destination host</param>
/// <param name="port">Destination port</param>
/// <returns>An FFD logger that works on reliable transport</returns>
/// <remarks>Log messages are not subject to loss, however this may affect performance</remarks>
public static IFieldFailureDataLogger CreateReliableFailureDataLogger(string loggerName, string host, int port)
{
return(new FieldFailureDataLogger(CollectorHelper.CreateUnreliableCollector(host, port), loggerName));
}
/// <summary>
/// Creates a logger using default configuration
/// </summary>
/// <returns></returns>
public static ILog GetLogger()
{
return(GetLogger(CollectorHelper.CreateCollector()));
}
/// <summary>
/// Creates the FFDA logger for monitors
/// </summary>
/// <returns></returns>
public static IFieldFailureAlerter CreateFailureAlerter()
{
return(new FieldFailureAlerter(CollectorHelper.CreateCollector()));
}
public static ILog CreateUdpLogger(IPAddress logbusIp, int logbusPort)
{
return(GetLogger(CollectorHelper.CreateUnreliableCollector(logbusIp, logbusPort)));
}
static void Main(string[] args)
{
bool reliable = args != null && args.Length > 0 && args[0] == "--reliable";
Console.CancelKeyPress += Console_CancelKeyPress;
Console.WriteLine("This program periodically measures the RTT for log messages sent by here");
if (!reliable)
{
Console.WriteLine("Going in unreliable mode. Messages are subject to loss.");
Console.WriteLine("Use the --reliable switch to go into reliable mode, where messages don't get lost.");
}
else
{
Console.WriteLine("Reliable mode activated. No messages will be lost because of the network.");
}
PropertyFilter hostFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value = Dns.GetHostName(),
propertyName = Property.Host
};
PropertyFilter pidFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value =
Process.GetCurrentProcess().Id.ToString(CultureInfo.InvariantCulture),
propertyName = Property.ProcessID
};
PropertyFilter idFilter = new PropertyFilter
{
value = "RTT",
comparison = ComparisonOperator.eq,
propertyName = Property.MessageID
};
_target = CollectorHelper.CreateCollector((reliable) ? "tls" : "udp");
FilterBase filter = hostFilter & pidFilter & idFilter;
_source = (reliable) ? ClientHelper.CreateReliableClient(filter) : ClientHelper.CreateUnreliableClient(filter);
_log = LoggerHelper.GetLogger("Logfile");
_source.MessageReceived += source_MessageReceived;
_source.Start();
while (true)
{
_id++;
DateTime curTimestamp = DateTime.UtcNow;
double millis = (curTimestamp - DateTime.Today).TotalMilliseconds;
string text = _id.ToString(CultureInfo.InvariantCulture) + "_" + millis.ToString(CultureInfo.InvariantCulture);
SyslogMessage message = new SyslogMessage(SyslogFacility.Local3, SyslogSeverity.Notice, text)
{
MessageId = "RTT"
};
_target.SubmitMessage(message);
if (!_ar.WaitOne(10000))
{
Console.WriteLine("RTT sent at {0} lost", curTimestamp);
_log.Warning("RTT sent at {0} lost", curTimestamp);
continue;
}
Thread.Sleep(3000);
}
}
