Example #1
0
        protected void ShowMessage(string strMessage,
                                   bool blnAllowLogToFile,
                                   bool blnPrecedeWithNewline,
                                   int intDuplicateHoldoffHours,
                                   eMessageTypeConstants eMessageType)
        {
            if (ShowMessagesAtConsole)
            {
                if (blnPrecedeWithNewline)
                {
                    Console.WriteLine();
                }
                Console.WriteLine(strMessage);
            }

            if (blnAllowLogToFile)
            {
                // Note that LogMessage will call RaiseMessageEvent
                LogMessage(strMessage, eMessageType, intDuplicateHoldoffHours);
            }
            else
            {
                RaiseMessageEvent(strMessage, eMessageType);
            }
        }
Example #2
0
        private void RaiseMessageEvent(string strMessage, eMessageTypeConstants eMessageType)
        {
            if (!string.IsNullOrWhiteSpace(strMessage))
            {
                if (string.Equals(strMessage, mRaiseMessageEventLastMessage) &&
                    DateTime.UtcNow.Subtract(mRaiseMessageEventLastReportTime).TotalSeconds < 0.5)
                {
                    // Duplicate message; do not raise any events
                }
                else
                {
                    mRaiseMessageEventLastReportTime = DateTime.UtcNow;
                    mRaiseMessageEventLastMessage    = string.Copy(strMessage);

                    switch (eMessageType)
                    {
                    case eMessageTypeConstants.Normal:
                        OnMessage(new MessageEventArgs(strMessage));
                        break;

                    case eMessageTypeConstants.Warning:
                        OnWarningMessage(new MessageEventArgs(strMessage));
                        break;

                    case eMessageTypeConstants.ErrorMsg:
                        OnErrorMessage(new MessageEventArgs(strMessage));
                        break;

                    default:
                        OnMessage(new MessageEventArgs(strMessage));
                        break;
                    }
                }
            }
        }
Example #3
0
        protected void LogMessage(string strMessage, eMessageTypeConstants eMessageType, int intDuplicateHoldoffHours)
        {
            // Note that CleanupPaths() will update mOutputFolderPath, which is used here if mLogFolderPath is blank
            // Thus, be sure to call CleanupPaths (or update mLogFolderPath) before the first call to LogMessage

            string strMessageType;

            switch (eMessageType)
            {
            case eMessageTypeConstants.Normal:
                strMessageType = "Normal";
                break;

            case eMessageTypeConstants.ErrorMsg:
                strMessageType = "Error";
                break;

            case eMessageTypeConstants.Warning:
                strMessageType = "Warning";
                break;

            default:
                strMessageType = "Unknown";
                break;
            }

            if (mLogFile == null && mLogMessagesToFile)
            {
                try
                {
                    if (string.IsNullOrWhiteSpace(mLogFilePath))
                    {
                        // Auto-name the log file
                        mLogFilePath  = Path.GetFileNameWithoutExtension(GetAppPath());
                        mLogFilePath += "_log";

                        if (mLogFileUsesDateStamp)
                        {
                            mLogFilePath += "_" + DateTime.Now.ToString("yyyy-MM-dd") + ".txt";
                        }
                        else
                        {
                            mLogFilePath += ".txt";
                        }
                    }

                    try
                    {
                        if (mLogFolderPath == null)
                        {
                            mLogFolderPath = string.Empty;
                        }

                        if (string.IsNullOrWhiteSpace(mLogFolderPath))
                        {
                            // Log folder is undefined; use mOutputFolderPath if it is defined
                            if (!string.IsNullOrWhiteSpace(mOutputFolderPath))
                            {
                                mLogFolderPath = string.Copy(mOutputFolderPath);
                            }
                        }

                        if (mLogFolderPath.Length > 0)
                        {
                            // Create the log folder if it doesn't exist
                            if (!Directory.Exists(mLogFolderPath))
                            {
                                Directory.CreateDirectory(mLogFolderPath);
                            }
                        }
                    }
                    catch (Exception)
                    {
                        mLogFolderPath = string.Empty;
                    }

                    if (!Path.IsPathRooted(mLogFilePath) && mLogFolderPath.Length > 0)
                    {
                        mLogFilePath = Path.Combine(mLogFolderPath, mLogFilePath);
                    }

                    bool blnOpeningExistingFile = File.Exists(mLogFilePath);

                    if ((blnOpeningExistingFile & mLogDataCache.Count == 0))
                    {
                        UpdateLogDataCache(mLogFilePath, DateTime.UtcNow.AddHours(-intDuplicateHoldoffHours));
                    }

                    mLogFile = new StreamWriter(new FileStream(mLogFilePath, FileMode.Append, FileAccess.Write, FileShare.Read))
                    {
                        AutoFlush = true
                    };

                    if (!blnOpeningExistingFile)
                    {
                        mLogFile.WriteLine("Date" + '\t' + "Type" + '\t' + "Message");
                    }
                }
                catch (Exception ex)
                {
                    // Error creating the log file; set mLogMessagesToFile to false so we don't repeatedly try to create it
                    mLogMessagesToFile = false;
                    HandleException("Error opening log file", ex);
                    // Note: do not exit this function if an exception occurs
                }
            }

            if ((mLogFile != null))
            {
                bool blnWriteToLog = true;

                string   strLogKey = strMessageType + "_" + strMessage;
                DateTime dtLastLogTime;
                bool     blnMessageCached;

                if (mLogDataCache.TryGetValue(strLogKey, out dtLastLogTime))
                {
                    blnMessageCached = true;
                }
                else
                {
                    blnMessageCached = false;
                    dtLastLogTime    = DateTime.UtcNow.AddHours(-(intDuplicateHoldoffHours + 1));
                }

                if (intDuplicateHoldoffHours > 0 && DateTime.UtcNow.Subtract(dtLastLogTime).TotalHours < intDuplicateHoldoffHours)
                {
                    blnWriteToLog = false;
                }


                if (blnWriteToLog)
                {
                    mLogFile.WriteLine(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss tt") + '\t' +
                                       strMessageType + '\t' +
                                       strMessage);

                    if (blnMessageCached)
                    {
                        mLogDataCache[strLogKey] = DateTime.UtcNow;
                    }
                    else
                    {
                        try
                        {
                            mLogDataCache.Add(strLogKey, DateTime.UtcNow);

                            if (mLogDataCache.Count > MAX_LOGDATA_CACHE_SIZE)
                            {
                                TrimLogDataCache();
                            }
                        }
                        // ReSharper disable once EmptyGeneralCatchClause
                        catch (Exception)
                        {
                            // Ignore errors here
                        }
                    }
                }
            }

            RaiseMessageEvent(strMessage, eMessageType);
        }
Example #4
0
 protected void LogMessage(string strMessage, eMessageTypeConstants eMessageType)
 {
     LogMessage(strMessage, eMessageType, intDuplicateHoldoffHours: 0);
 }