private void RemoveLogFileInfoObjects(IEnumerable <LogFileInfo> toBeRemovedList)
{
foreach (LogFileInfo logFileInfo in toBeRemovedList)
{
LogFileInfo logFileInfo2;
this.logsJustFinishedParsing.TryRemove(logFileInfo.FileName, out logFileInfo2);
logFileInfo.Status = ProcessingStatus.CompletedProcessing;
logFileInfo.WatermarkFileObj.Dispose();
if (logFileInfo.FileExists)
{
logFileInfo.WatermarkFileObj.CreateDoneFile();
}
ILogFileInfo logFileInfo3;
if (this.knownLogNameToLogFileMap.TryRemove(logFileInfo.FileName, out logFileInfo3))
{
string text = string.Format("log file {0} is removed from KnownLogNameToLogFileMap.", logFileInfo.FileName);
ExTraceGlobals.LogMonitorTracer.TraceDebug((long)this.GetHashCode(), text);
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.LogFileDeletedFromKnownLogNameToLogFileMap, text, "", logFileInfo.FileName);
}
else
{
string.Format("The log {0} disappeared from KnownLogNameToLogFileMap. This indicates a bug somewhere", logFileInfo.FullFileName);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogDisappearedFromKnownLogNameToLogFileMap, logFileInfo.FullFileName, new object[]
{
logFileInfo.FullFileName
});
ServiceLogger.LogError(ServiceLogger.Component.LogMonitor, (LogUploaderEventLogConstants.Message) 2147748808U, "", "", logFileInfo.FullFileName);
}
}
}
private void ReportCompleteLogs(List <LogFileInfo> completeLogs)
{
foreach (LogFileInfo logFileInfo in completeLogs)
{
this.perfCounterInstance.TotalCompletedLogs.Increment();
string message = string.Format("The processing of log {0} is completed.", logFileInfo.FullFileName);
ExTraceGlobals.LogMonitorTracer.TraceDebug((long)this.GetHashCode(), message);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogMonitorLogCompleted, logFileInfo.FullFileName, new object[]
{
logFileInfo.FullFileName
});
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.LogMonitorLogCompleted, "", "", logFileInfo.FullFileName);
}
}
internal void ClearnupWmkDoneFiles(string dir, string filter)
{
foreach (string text in Directory.EnumerateFiles(dir, filter))
{
try
{
string path = this.watermarkFileHelper.DeduceLogFullFileNameFromDoneOrWatermarkFileName(text);
if (!File.Exists(path))
{
if (this.knownLogNameToLogFileMap.ContainsKey(Path.GetFileName(path)))
{
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.DeletingFile, "Skipped for it's still processed by this logMonitor", this.instance, text);
}
else
{
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.DeletingFile, "Delete Done or watermark file", this.instance, text);
File.Delete(text);
}
}
}
catch (IOException ex)
{
string text2 = string.Format("Failed to clean up {0}. Exception: {1}.", text, ex.Message);
ExTraceGlobals.LogMonitorTracer.TraceError((long)this.GetHashCode(), text2);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogMonitorWatermarkCleanupFailed, text, new object[]
{
text,
ex.Message
});
ServiceLogger.LogError(ServiceLogger.Component.LogMonitor, (LogUploaderEventLogConstants.Message) 3221228476U, text2, "", text);
}
catch (UnauthorizedAccessException ex2)
{
string text3 = string.Format("Failed to clean up {0}. Exception: {1}.", text, ex2);
ExTraceGlobals.LogMonitorTracer.TraceError((long)this.GetHashCode(), text3);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogMonitorWatermarkCleanupFailed, text, new object[]
{
text,
ex2
});
ServiceLogger.LogError(ServiceLogger.Component.LogMonitor, (LogUploaderEventLogConstants.Message) 3221228476U, text3, "", text);
}
}
}
public void DoWork(object obj)
{
ArgumentValidator.ThrowIfNull("obj", obj);
if (string.IsNullOrEmpty(Thread.CurrentThread.Name))
{
Thread.CurrentThread.Name = string.Format("Writer {0} for log type {1}", this.id, this.instance);
}
ServiceLogger.LogDebug(ServiceLogger.Component.DatabaseWriter, LogUploaderEventLogConstants.Message.LogBatchEnqueue, string.Format("DoWork: called : thread={0}, log={1} ?---LogWriter", Thread.CurrentThread.ManagedThreadId, this.instance), "", "");
this.cancellationContext = (CancellationContext)obj;
while (!this.CheckServiceStopRequest("DoWork()"))
{
this.DequeueAndWriteOneItem();
}
string message = string.Format("Writer {0} for log type {1} stopped.", this.id, this.instance);
ExTraceGlobals.WriterTracer.TraceDebug((long)this.GetHashCode(), message);
ServiceLogger.LogInfo(ServiceLogger.Component.DatabaseWriter, LogUploaderEventLogConstants.Message.LogMonitorRequestedStop, Thread.CurrentThread.Name, this.instance, "");
this.stopped = true;
}
public void DoWork(object obj)
{
ArgumentValidator.ThrowIfNull("obj", obj);
this.cancellationContext = (CancellationContext)obj;
CancellationToken stopToken = this.cancellationContext.StopToken;
if (string.IsNullOrEmpty(Thread.CurrentThread.Name))
{
Thread.CurrentThread.Name = string.Format("Reader {0} for log prefix {1}", this.id, this.instance);
}
string text = string.Format("Reader {0} for log prefix {1} started", this.id, this.instance);
ExTraceGlobals.ReaderTracer.TraceInformation(0, (long)this.GetHashCode(), text);
ServiceLogger.LogDebug(ServiceLogger.Component.LogReader, LogUploaderEventLogConstants.Message.LogBatchEnqueue, string.Format("DoWork: called : thread={0}, {1} ?---LogReader", Thread.CurrentThread.ManagedThreadId, text), "", "");
while (!this.CheckServiceStopRequest("DoWork"))
{
this.ReadLog();
}
string message = string.Format("Reader {0} for log prefix {1} stopped", this.id, this.instance);
ExTraceGlobals.ReaderTracer.TraceInformation(0, (long)this.GetHashCode(), message);
ServiceLogger.LogInfo(ServiceLogger.Component.LogReader, LogUploaderEventLogConstants.Message.LogMonitorRequestedStop, Thread.CurrentThread.Name, this.instance, "");
this.stopped = true;
}
internal void DequeueAndWriteOneItem()
{
string text = string.Empty;
IWatermarkFile watermarkFile = null;
try
{
T t = this.queue.Dequeue(this.cancellationContext);
if (t != null)
{
this.perfCounterInstance.BatchQueueLength.Decrement();
text = t.FullLogName;
watermarkFile = this.logManager.FindWatermarkFileObject(text);
if (ExTraceGlobals.WriterTracer.IsTraceEnabled(TraceType.DebugTrace))
{
StringBuilder stringBuilder = new StringBuilder();
foreach (LogFileRange logFileRange in t.LogRanges)
{
string value = string.Format("({0}, {1}) ", logFileRange.StartOffset, logFileRange.EndOffset);
stringBuilder.Append(value);
}
string message = string.Format("For log {0}, writer {1} get batch that has {2} ranges: {3}", new object[]
{
text,
this.id,
t.LogRanges.Count,
stringBuilder.ToString()
});
ExTraceGlobals.WriterTracer.TraceDebug((long)this.GetHashCode(), message);
}
this.WriteBatch(t);
}
else if (!this.CheckServiceStopRequest("DequeueAndWriteOneItem()"))
{
Tools.DebugAssert(this.cancellationContext.StopToken.IsCancellationRequested, "If Enqueue is not cancelled, it should always get a batch back");
}
}
catch (FaultException ex)
{
ExTraceGlobals.WriterTracer.TraceError <string, string>((long)this.GetHashCode(), "Writer failed to write data through web service DAL when processing log {0}. Check the event log on the FFO web service role. The exception is: {1}.", text, ex.Message);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_WebServiceWriteException, ex.Message, new object[]
{
text,
ex.ToString()
});
ServiceLogger.LogError(ServiceLogger.Component.DatabaseWriter, (LogUploaderEventLogConstants.Message) 3221489634U, ex.Message, this.instance, text);
}
catch (CommunicationException ex2)
{
ExTraceGlobals.WriterTracer.TraceError <string, string>((long)this.GetHashCode(), "Writer failed to write data through web service DAL when processing log {0}. The exception is: {1}.", text, ex2.Message);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_WebServiceWriteException, ex2.Message, new object[]
{
text,
ex2.ToString()
});
ServiceLogger.LogError(ServiceLogger.Component.DatabaseWriter, (LogUploaderEventLogConstants.Message) 3221489633U, ex2.Message, this.instance, text);
}
catch (ADTopologyEndpointNotFoundException ex3)
{
ExTraceGlobals.WriterTracer.TraceError <string, string>((long)this.GetHashCode(), "Writer caught an ADTopologyEndpointNotFoundException when processing log {0}. Details is: {1}", text, ex3.Message);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_ADTopologyEndpointNotFound, ex3.Message, new object[]
{
text,
ex3.Message
});
ServiceLogger.LogError(ServiceLogger.Component.DatabaseWriter, (LogUploaderEventLogConstants.Message) 3221489629U, ex3.Message, this.instance, text);
}
catch (Exception ex4)
{
if (!(ex4 is ThreadAbortException) || !this.cancellationContext.StopToken.IsCancellationRequested)
{
string text2 = string.Format("Writer caught an exception when processing log {0}: {1}", text, ex4);
ExTraceGlobals.WriterTracer.TraceError((long)this.GetHashCode(), text2);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_DatabaseWriterUnknownException, ex4.Message, new object[]
{
text,
ex4
});
EventNotificationItem.Publish(ExchangeComponent.Name, "UnexpectedWriterError", null, text2, ResultSeverityLevel.Error, false);
this.perfCounterInstance.TotalUnexpectedWriterErrors.Increment();
ServiceLogger.LogError(ServiceLogger.Component.DatabaseWriter, (LogUploaderEventLogConstants.Message) 3221489617U, text2, this.instance, text);
throw;
}
Thread.ResetAbort();
ServiceLogger.LogInfo(ServiceLogger.Component.DatabaseWriter, LogUploaderEventLogConstants.Message.LogMonitorRequestedStop, Thread.CurrentThread.Name + " received thread abort event", this.instance, "");
}
finally
{
if (watermarkFile != null)
{
watermarkFile.InMemoryCountDecrease();
}
}
}
public virtual void Stop()
{
if (this.checkDirectoryTimer != null)
{
this.checkDirectoryTimer.Dispose();
this.checkDirectoryTimer = null;
}
if (this.stopTokenSource != null)
{
ExTraceGlobals.LogMonitorTracer.TraceInformation <string>(0, (long)this.GetHashCode(), "LogMonitor of type {0} sent stop requests to readers and writers.", this.instance);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogMonitorRequestedStop, this.instance, new object[]
{
this.instance
});
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.LogMonitorRequestedStop, "", this.instance, "");
this.stopTokenSource.Cancel();
if (this.stopWaitHandles != null)
{
ManualResetEvent[] array = (from h in this.stopWaitHandles
where h != null
select h).ToArray <ManualResetEvent>();
if (array.Length == 0 || WaitHandle.WaitAll(array, this.config.ServiceStopWaitTime))
{
ExTraceGlobals.LogMonitorTracer.TraceInformation <string>(0, (long)this.GetHashCode(), "No worker threads of log type {0} is running.", this.instance);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogMonitorAllStopped, this.instance, new object[]
{
this.instance
});
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.LogMonitorAllStopped, "", this.instance, "");
}
else
{
ExTraceGlobals.LogMonitorTracer.TraceInformation <string>(0, (long)this.GetHashCode(), "Timeout waiting for all readers and writers of log type {0} to stop. Call thread's abort anyway.", this.instance);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogMonitorStopTimedOut, this.instance, new object[]
{
this.instance
});
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.LogMonitorStopTimedOut, "", this.instance, "");
foreach (Thread thread in this.workerThreads)
{
if (thread.IsAlive)
{
thread.Abort();
}
}
Thread.Sleep(1000);
}
}
}
else
{
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogMonitorAllStopped, null, new object[]
{
this.instance
});
ServiceLogger.LogInfo(ServiceLogger.Component.LogMonitor, LogUploaderEventLogConstants.Message.LogMonitorAllStopped, "", this.instance, "");
}
this.workerThreads.Clear();
if (this.batchQueue != null)
{
this.batchQueue.Close();
}
this.DisposeAllWatermarkFileObjects();
}
internal void ReadLog()
{
LogFileInfo logFileInfo = null;
int num = 0;
try
{
if (this.batchQueue.IsFull)
{
num = Tools.RandomizeTimeSpan(this.config.ReaderSleepTime, this.config.ReaderSleepTimeRandomRange);
string text = string.Format("The queue for log prefix {0} is full. Reader will not parse it until the queue is no longer full.", this.instance);
ExTraceGlobals.ReaderTracer.TraceWarning((long)this.GetHashCode(), text);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogReaderQueueFull, this.instance, new object[]
{
this.instance
});
long num2 = DateTime.UtcNow.Ticks - this.lastTimeWhenQeueFull;
if (num2 > 1800000000L)
{
this.lastTimeWhenQeueFull = DateTime.UtcNow.Ticks;
ServiceLogger.LogWarning(ServiceLogger.Component.LogReader, (LogUploaderEventLogConstants.Message) 2147487654U, text, this.instance, "");
}
}
else
{
logFileInfo = this.logMonitor.GetLogForReaderToProcess();
if (logFileInfo == null)
{
num = Tools.RandomizeTimeSpan(this.config.ReaderSleepTime, this.config.ReaderSleepTimeRandomRange);
}
else
{
this.ProcessLog(logFileInfo);
}
}
}
catch (FileNotFoundException ex)
{
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogReaderLogMissing, ex.Message, new object[]
{
Thread.CurrentThread.Name,
ex
});
ServiceLogger.LogError(ServiceLogger.Component.LogReader, (LogUploaderEventLogConstants.Message) 2147487659U, ex.Message, this.instance, "");
this.logMonitor.ReaderCompletedProcessingLog(logFileInfo);
return;
}
catch (IOException ex2)
{
string text2 = (logFileInfo == null) ? "unknown log" : logFileInfo.FullFileName;
string text3 = string.Format("Caught an IOException when reading log {0}. Exception: {1}", text2, ex2);
ExTraceGlobals.LogMonitorTracer.TraceError((long)this.GetHashCode(), text3);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_ReadLogCaughtIOException, logFileInfo.FullFileName, new object[]
{
logFileInfo.FullFileName,
ex2
});
ServiceLogger.LogError(ServiceLogger.Component.LogReader, (LogUploaderEventLogConstants.Message) 3221229485U, text3, this.instance, text2);
if (!ex2.Message.Contains("Insufficient system resources exist to complete the requested service"))
{
throw;
}
this.logMonitor.ReaderCompletedProcessingLog(logFileInfo);
}
catch (NotSupportedException ex3)
{
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_UnsupportedLogVersion, "UnSupportedLogVersion", new object[]
{
logFileInfo.FullFileName,
ex3
});
ServiceLogger.LogError(ServiceLogger.Component.LogMonitor, (LogUploaderEventLogConstants.Message) 3221229488U, ex3.Message, this.instance, logFileInfo.FullFileName);
EventNotificationItem.Publish(ExchangeComponent.Name, "UnsupportedLogVersion", null, ex3.Message, ResultSeverityLevel.Error, false);
throw ex3;
}
catch (Exception ex4)
{
if (!(ex4 is ThreadAbortException) || !this.cancellationContext.StopToken.IsCancellationRequested)
{
string text4 = (logFileInfo == null) ? "unknown log" : logFileInfo.FullFileName;
string text5 = string.Format("{0} processing {1} catches an exception: {2}", Thread.CurrentThread.Name, text4, ex4);
ExTraceGlobals.ReaderTracer.TraceError((long)this.GetHashCode(), text5);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogReaderUnknownError, null, new object[]
{
Thread.CurrentThread.Name,
text4,
ex4
});
EventNotificationItem.Publish(ExchangeComponent.Name, "LogReaderUnknownError", null, text5, ResultSeverityLevel.Error, false);
this.perfCounterInstance.TotalLogReaderUnknownErrors.Increment();
ServiceLogger.LogError(ServiceLogger.Component.LogReader, (LogUploaderEventLogConstants.Message) 3221229474U, text5, this.instance, text4);
throw;
}
Thread.ResetAbort();
ServiceLogger.LogInfo(ServiceLogger.Component.DatabaseWriter, LogUploaderEventLogConstants.Message.LogMonitorRequestedStop, Thread.CurrentThread.Name + " received thread abort event", this.instance, "");
}
if (num > 0 && this.cancellationContext.StopToken.WaitHandle.WaitOne(num))
{
this.cancellationContext.StopWaitHandle.Set();
}
}
internal void ProcessLog(LogFileInfo log)
{
FileStream fileStream = null;
ServiceLogger.LogDebug(ServiceLogger.Component.LogReader, LogUploaderEventLogConstants.Message.LogReaderStartedParsingLog, string.Format("reprocessing or begin to process, isActive {0} +++++++++", log.IsActive), this.instance, log.FullFileName);
if (log.Status == ProcessingStatus.NeedProcessing)
{
log.Status = ProcessingStatus.InProcessing;
PerfCountersInstanceCache.GetInstance(this.instance).TotalNewLogsBeginProcessing.Increment();
ExTraceGlobals.ReaderTracer.TraceDebug <string, string>((long)this.GetHashCode(), "{0} started parsing log {1}", Thread.CurrentThread.Name, log.FullFileName);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogReaderStartedParsingLog, log.FileName, new object[]
{
this.id,
log.FullFileName
});
ServiceLogger.LogInfo(ServiceLogger.Component.LogReader, LogUploaderEventLogConstants.Message.LogReaderStartedParsingLog, null, this.instance, log.FullFileName);
}
try
{
string defaultLogVersion;
fileStream = this.OpenLogWithRetry(log.FullFileName, out defaultLogVersion);
if (fileStream == null)
{
if (!this.isStopRequested)
{
string text = string.Format("Failed to open log file {0}", log.FullFileName);
ExTraceGlobals.ReaderTracer.TraceError((long)this.GetHashCode(), text);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogReaderFileOpenFailed, log.FullFileName, new object[]
{
log.FullFileName
});
EventNotificationItem.Publish(ExchangeComponent.Name, "FailToOpenLogFile", null, text, ResultSeverityLevel.Error, false);
ServiceLogger.LogError(ServiceLogger.Component.LogReader, (LogUploaderEventLogConstants.Message) 3221229475U, text, this.instance, log.FullFileName);
}
}
else
{
if (string.IsNullOrWhiteSpace(defaultLogVersion))
{
defaultLogVersion = this.logMonitorHelper.GetDefaultLogVersion();
ExTraceGlobals.ReaderTracer.TraceWarning <string, string>((long)this.GetHashCode(), "Failed to figure out version of log file {0}. Use default version {1} instead.", log.FullFileName, defaultLogVersion);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_FailedToGetVersionFromLogHeader, log.FullFileName, new object[]
{
log.FullFileName,
defaultLogVersion
});
ServiceLogger.LogError(ServiceLogger.Component.LogReader, (LogUploaderEventLogConstants.Message) 2147487660U, null, this.instance, log.FullFileName);
}
CsvTable logSchema = this.logMonitorHelper.GetLogSchema(new Version(defaultLogVersion));
CsvFieldCache csvFieldCache = new CsvFieldCache(logSchema, fileStream, 32768);
int num = 0;
this.logHeaderEndOffset = csvFieldCache.Position;
ExTraceGlobals.ReaderTracer.TraceDebug <string, long>((long)this.GetHashCode(), "The end offset of the header of {0} is {1}.", log.FullFileName, this.logHeaderEndOffset);
bool flag = false;
while (!flag)
{
if (this.CheckServiceStopRequest("ProcessLog()"))
{
return;
}
LogFileRange logFileRange = log.WatermarkFileObj.GetBlockToReprocess();
if (logFileRange == null)
{
logFileRange = log.WatermarkFileObj.GetNewBlockToProcess();
flag = true;
if (logFileRange == null)
{
break;
}
}
if (num == 0)
{
long startOffset = logFileRange.StartOffset;
this.inputBuffer = new InputBuffer <T>(this.config.BatchSizeInBytes, startOffset, log, this.batchQueue, this.logPrefix, this.logMonitorHelper, this.messageBatchFlushInterval, this.cancellationContext, this.config.InputBufferMaximumBatchCount, this.instance);
}
bool isFirstBlock = num == 0;
this.inputBuffer.BeforeDataBlockIsProcessed(logFileRange, isFirstBlock);
this.ProcessBlock(csvFieldCache, logFileRange, log);
this.inputBuffer.AfterDataBlockIsProcessed();
if (this.isStopRequested)
{
return;
}
num++;
}
this.EnqueueLastBatchParsed();
log.LastProcessedTime = DateTime.UtcNow;
if (!log.IsActive)
{
log.Status = ProcessingStatus.ReadyToWriteToDatabase;
ExTraceGlobals.ReaderTracer.TraceInformation <string>(0, (long)this.GetHashCode(), "Finished parsing log {0}", log.FullFileName);
EventLogger.Logger.LogEvent(LogUploaderEventLogConstants.Tuple_LogReaderFinishedParsingLog, log.FullFileName, new object[]
{
log.FullFileName
});
ServiceLogger.LogInfo(ServiceLogger.Component.LogReader, LogUploaderEventLogConstants.Message.LogReaderFinishedParsingLog, null, this.instance, log.FullFileName);
}
}
}
finally
{
ServiceLogger.LogDebug(ServiceLogger.Component.LogReader, LogUploaderEventLogConstants.Message.LogReaderFinishedParsingLog, string.Format("Finished parsing for this round, isActive {0} +++++++++", log.IsActive), this.instance, log.FullFileName);
this.logMonitor.ReaderCompletedProcessingLog(log);
this.Cleanup(fileStream);
}
}
