public IEnumerable<LogEvent> Evaluate(string logFileName, string line)
{
_rwLocker.EnterReadLock();
try
{
foreach (EventEvaluatorRule eventEvaluationRule in _rules)
{
Match m = eventEvaluationRule.RegexRule.Match(line);
if (!m.Success) continue;
if (eventEvaluationRule.HasExcludingRules && eventEvaluationRule.ExcludingRules.Any(r => r.Match(line).Success)) continue;
LogEvent evt = new LogEvent
{
Source = eventEvaluationRule.GetSource(logFileName, m),
Category = eventEvaluationRule.GetCounterCategory(logFileName, m),
Counter = eventEvaluationRule.GetCounterName(logFileName, m),
Instance = eventEvaluationRule.GetInstance(logFileName, m),
Type = eventEvaluationRule.EventType,
DateTime = eventEvaluationRule.GetDateTime(logFileName, m),
ExtendedData = eventEvaluationRule.GetExtendedData(logFileName, m),
Value = eventEvaluationRule.GetValue(logFileName, m)
};
yield return evt;
}
}
finally
{
_rwLocker.ExitReadLock();
}
}
public static LogEvent Deserialize(byte[] data)
{
MemoryStream stream = new MemoryStream(data);
LogEvent result = new LogEvent();
result.Type = (EventType)Packer.UnPackInt32(stream);
result.DateTime = new DateTime( Packer.UnPackInt64(stream));
result.Source = Packer.UnPackString(stream);
result.Category = Packer.UnPackString( stream);
result.Counter = Packer.UnPackString(stream);
result.Instance = Packer.UnPackString(stream);
result.ExtendedData = Packer.UnPackString(stream);
result.Value = Packer.UnPackString(stream);
return result;
}
public byte[] Serialize(LogEvent logEvent)
{
MemoryStream stream = new MemoryStream();
Packer.PackInt32((int) logEvent.Type, stream);
Packer.PackInt64(DateTime.Ticks,stream);
Packer.PackString(Source, stream);
Packer.PackString(Category,stream);
Packer.PackString(Counter,stream);
Packer.PackString(Instance,stream);
Packer.PackString(ExtendedData,stream);
Packer.PackString(Value,stream);
int len = (int)stream.Position;
stream.Seek(0, SeekOrigin.Begin);
byte[] result = new byte[len];
stream.Read(result, 0, len);
return result;
}
public GetRequestAsyncState(HttpWebRequest request, LogEvent logEvent)
{
Request = request;
LogEvent = logEvent;
}
private static void OutToConsole(object sender, LogEvent e)
{
Console.WriteLine(e);
}
private static void OutToServer(object sender, LogEvent e)
{
if (_tcpClient == null)
{
SheduleReconnect();
return;
}
byte[] data = e.Serialize();
_tcpClientLocker.EnterReadLock();
try
{
_tcpClient.Send(new MessagePacket(data).GetBytesForTransfer());
}
catch (Exception ex)
{
_logger.Error("Error while sending\r\n" + ex);
}
finally
{
_tcpClientLocker.ExitReadLock();
}
}
private static void OutToHttpServer(object sender, LogEvent e)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://lit-karmazin:80/Temporary_Listen_Addresses/postbinary");
request.KeepAlive = true;
request.Method = "POST";
request.BeginGetRequestStream(OnRequestStreamGot, new GetRequestAsyncState(request,e));
}
private static void CountEvents(object sender, LogEvent e)
{
_logger.Debug(e);
if (_lastCountEventsCheckPoint.AddMinutes(1) > DateTime.Now)
Interlocked.Increment(ref _totalEvents);
else
{
lock (_eLock)
{
if (_lastCountEventsCheckPoint.AddMinutes(1) <= DateTime.Now)
{
_logger.Info(_totalEvents + " events generated");
_totalEvents = 0;
_lastCountEventsCheckPoint = DateTime.Now;
}
}
}
}
public LogEventArgs(LogEvent logEvent)
{
LogEvent = logEvent;
}
private static void OutToHttpServer(object sender, LogEvent e)
{
byte[] data = e.Serialize();
Uri url = new Uri("http://lit-karmazin:80/Temporary_Listen_Addresses/postbinary");
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.ServicePoint.Expect100Continue = false;
request.ServicePoint.ConnectionLimit = 2;
request.ServicePoint.UseNagleAlgorithm = false;
request.KeepAlive = true;
request.Method = "POST";
Stream requestStream = request.GetRequestStream();
requestStream.Write(data, 0, data.Length);
requestStream.Flush();
requestStream.Close();
try
{
request.GetResponse();
requestStream.Dispose();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private static void Main(string[] args)
{
LogEvent le = new LogEvent(EventType.Counter, DateTime.Now,"1","1","2","3","","4");
for (int i = 0; i < 10; i++)
{
OutToHttpServer(null, le);
}
/*Test12();
Test14();*/
Console.WriteLine("Done");
Console.ReadLine();
}
private static double SlowPokeParse(LogEvent logEvent)
{
Thread.Sleep(50);
return Double.Parse(logEvent.Value);
}
public void Push(LogEvent logEvent)
{
var props = new Dictionary<string, string>();
props["cCat"] = logEvent.Category;
props["cName"] = logEvent.Counter;
props["src"] = logEvent.Source;
if (!String.IsNullOrEmpty(logEvent.Instance)) props["instance"] = logEvent.Instance;
if (!String.IsNullOrEmpty(logEvent.ExtendedData)) props["ext_data"] = logEvent.ExtendedData;
var aggregationKey = new AggregationKey(logEvent.DateTime.RoundTo(_aggregationPeriod), props);
/*_events.AddOrUpdate(aggregationKey,
new ConcurrentBag<double>() {SlowPokeParse(logEvent)},
(key, bag) =>
{
bag.Add(SlowPokeParse(logEvent));
return bag;
});
*/
var value = Double.Parse(logEvent.Value);
//_rwLock.EnterReadLock();
try
{
_bag.Add(new Tuple<AggregationKey, double>(aggregationKey, value));
//_events.GetOrAdd(aggregationKey, new ConcurrentBag<double>()).Add(value);
}
finally
{
// _rwLock.ExitReadLock();
}
}
public bool CanProcess(LogEvent logEvent)
{
return logEvent.Category == _counterCategoryFilter && logEvent.Counter == _counterNameFilter;
}
public void Push(LogEvent logEvent)
{
_eventSubject.OnNext(logEvent);
}
private CounterGroup CreateCounterGroup(CounterGroup.GroupBy groupBy, LogEvent eventArgs)
{
return new CounterGroup(
eventArgs.Counter,
groupBy.HasFlag(CounterGroup.GroupBy.Source)? "ALL_SOURCES" : eventArgs.Source,
groupBy.HasFlag(CounterGroup.GroupBy.Instance) ? "ALL_INSTANCES" : eventArgs.Instance,
groupBy.HasFlag(CounterGroup.GroupBy.ExtendedData) ? "ALL_EXTDATA" : eventArgs.ExtendedData
);
}
