public static void Log(string logFile, int maxLogSizeKb, DateTime logTime, string header, EventLogEntryType? eventLogEntryType, string format, params object[] parameters) { try { if (string.IsNullOrEmpty(logFile)) { if (eventLogEntryType.HasValue) Log(eventLogEntryType.Value, logTime, header, format, parameters); } else { lock (GetSync(logFile)) { var log = string.Format("{0}: {1} : {2}", logTime.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture), header, string.Format(format, parameters)); var info = new FileInfo(logFile); using (var fs = new StreamWriter(logFile, info.Length + log.Length <= maxLogSizeKb * 1024, Encoding.UTF8)) { fs.WriteLine(log); } } } } catch { } }
/// <summary> /// The log exception. /// </summary> /// <param name="message">The message.</param> /// <param name="level">The level.</param> /// <param name="frame">The frame.</param> public void LogException(string message, EventLogEntryType level, int frame) { try { var callStack = new StackFrame(frame, true); string filename = string.Empty; try { filename = callStack.GetFileName(); } catch { } string method = callStack.GetMethod().ToString(); int linenumber = callStack.GetFileLineNumber(); string stackTrace = string.Empty; if (level == EventLogEntryType.Error) { stackTrace = "Stack Trace: " + Environment.StackTrace; } else { method = string.Empty; linenumber = 0; } this.LogToDb(level, filename, method, linenumber, message, stackTrace); } catch { // Do nothing since logging is unavailable } }
private void AddFileEventLog(string message, EventLogEntryType logType = EventLogEntryType.Information, string moduleName = "", int codeErreur = 0, bool fromWindowsLogEvent = false) { System.IO.StreamWriter w = null; System.Text.StringBuilder str = new System.Text.StringBuilder(); try { string strPath = System.IO.Path.GetDirectoryName(_logFilePath); if (!System.IO.Directory.Exists(strPath)) System.IO.Directory.CreateDirectory(strPath); w = new System.IO.StreamWriter(_logFilePath, true, System.Text.Encoding.Default); str.AppendFormat("[{0,-10:G} - {1,-8:G}]", DateTime.Now.ToShortDateString(), DateTime.Now.ToLongTimeString()); str.AppendFormat(" {0}", Const.DEFAULT_APPLICATION_NAME); if (!string.IsNullOrEmpty(moduleName)) str.AppendFormat(" ({0})", moduleName); str.AppendFormat(" - {0}", logType.ToString()); if (codeErreur != 0) str.AppendFormat(" - Code : {0}", codeErreur); str.Append("\r\n"); str.Append(message); str.Append("\r\n"); w.WriteLine(str.ToString()); } catch (Exception ex) { if (!fromWindowsLogEvent) { AddWindowsEventLog("Impossible d'écrire dans le fichier de log : " + _logFilePath + "\r\n" + message + "\r\nException : " + ex.Message, EventLogEntryType.Error, moduleName, 0, true); } } finally { if ((w != null)) w.Close(); } }
internal static void Log(string message, EventLogEntryType level = EventLogEntryType.Information) { TeamFoundationApplicationCore.Log(message, 9999, level); if (PluginConfiguration.Instance.HasLog) File.AppendAllText(PluginConfiguration.Instance.LogFile, message + Environment.NewLine); }
private void AddWindowsEventLog(string message, EventLogEntryType logType = EventLogEntryType.Information, string moduleName = "", int codeErreur = 0, bool fromFileLogEvent = false) { EventLog evLog = new EventLog(Const.WINDOWS_LOG_NAME); message = string.Concat(message, "\r\n", "Module : ", moduleName); evLog.Source = Const.DEFAULT_APPLICATION_NAME; InitWindowsEventLog(); try { evLog.WriteEntry(message, logType, codeErreur); } catch (Exception ex) { if (!fromFileLogEvent) { AddFileEventLog("Impossible d'écrire dans le journal de log " + Log.Const.WINDOWS_LOG_NAME + ".\r\nLe journal doit être créé préalablement avec un compte Administrateur.\r\nMessage :\r\n" + message + "\r\nException : " + ex.Message, logType, moduleName, codeErreur, true); } } finally { evLog.Close(); } }
/// <summary> /// This method inform the Logging Manager whether it will accept the /// category for logging. /// </summary> /// <param name="category">The logging category.</param> /// <param name="type">The envent log entry type category.</param> /// <returns>A boolean value. True indicates the category is accepted.</returns> public override bool AcceptCategory(string category, EventLogEntryType type) { if (category == "EventLog") return true; return base.AcceptCategory(category, type); }
//Write entry log with custome event log entry type public void WriteEntry(string message, EventLogEntryType entryType) { if (enableDebugLog) { debugLog.WriteEntry(message, entryType); } }
/// <summary> /// Writes the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="execption">The execption.</param> /// <param name="eventLogType">Type of the event log.</param> private void Write(object message, Exception execption, EventLogEntryType eventLogType) { StringBuilder sb = new StringBuilder(); System.Diagnostics.EventLog eventLogger = new System.Diagnostics.EventLog(); if (!System.Diagnostics.EventLog.SourceExists(eventLogSource)) { System.Diagnostics.EventLog.CreateEventSource(eventLogSource, eventLogName); } sb.Append(message).Append(NEW_LINE); while (execption != null) { sb.Append("Message: ").Append(execption.Message).Append(NEW_LINE) .Append("Source: ").Append(execption.Source).Append(NEW_LINE) .Append("Target site: ").Append(execption.TargetSite).Append(NEW_LINE) .Append("Stack trace: ").Append(execption.StackTrace).Append(NEW_LINE); // Walk the InnerException tree execption = execption.InnerException; } eventLogger.Source = eventLogSource; eventLogger.WriteEntry(String.Format(ERROR_MSG, eventLogName, sb), eventLogType); }
public LoggingUtil(EventLogEntryType min, EventLogEntryType max, String applicationName) { isSytemEvent = true; minSysLevel = min; maxSysLevel = max; _logFile.Source = applicationName; }
public void EventLogWriteEntry(string message, EventLogEntryType type) { if (HostedApplication.EventLogEnabled) { EventLog.WriteEntry(message, type); } }
static void EventLog(String evt, EventLogEntryType tpy) { if (bEventLog) eventLog.WriteEntry(evt, tpy); //Console.WriteLine(evt); //MessageBox.Show(evt); }
// 把错误信息写到日志文件里 public void WriteErrorLog(string strText, EventLogEntryType type = EventLogEntryType.Error) { EventLog Log = new EventLog(); Log.Source = "dp2ZServer"; Log.WriteEntry(strText, EventLogEntryType.Error); }
/// <summary/> /// <param name="message"/> /// <param name="eventLogType"/> /// <exclude/> public virtual void Log(string message, EventLogEntryType eventLogType) { lock (lockObj) { this.eventLog.WriteEntry(message, eventLogType, this.eventId); } }
public override void WriteLine(EventLogEntryType type, string message) { lock (_trace) { _trace.WriteLine(message, type.ToString()); } }
public static void Log(object sender, EventLogEntryType logType, string information) { if (sender == null) sender = new object(); if (!Enabled) return; if (!ShowAll && logType != EventLogEntryType.Error && logType != EventLogEntryType.SuccessAudit) return; var origin = sender.GetType().FullName; var trace = new StringBuilder(); if (logType == EventLogEntryType.Error) { var t = new StackTrace(); for (var i = 0; i < t.FrameCount; ++i) { var declaringType = t.GetFrame(i).GetMethod().DeclaringType; if (declaringType != null) trace.Append(declaringType.FullName + "." + t.GetFrame(i).GetMethod().Name + "\r\n"); } } if (_log != null) { try { _log.WriteEntry(origin + ": " + information + "\r\n\r\nTRACE:\r\n" + trace, logType); } catch {} } OnEvent?.Invoke(logType, sender, trace.ToString(), information); }
public static void WriteLog(string message, EventLogEntryType type) { //WindowsIdentity winId = (WindowsIdentity)System.Security.Principal.WindowsIdentity.GetCurrent(); //WindowsImpersonationContext ctx = null; try { // Start impersonating //ctx = winId.Impersonate(); // Now impersonating // Access resources using the identity of the authenticated user System.Diagnostics.EventLog appLog = new System.Diagnostics.EventLog(); appLog.Source = "PMM Presentation"; appLog.WriteEntry(message, type); } // Prevent exceptions from propagating catch { } //finally //{ // // Revert impersonation // if (ctx != null) // ctx.Undo(); //} }
/// <summary> /// Logs the specified STR. /// </summary> /// <param name="message">The message.</param> /// <param name="msgType">Type of the MSG.</param> /// <param name="args">The args.</param> internal static void Write(string message, EventLogEntryType msgType, params string[] args) { if (string.IsNullOrEmpty(message)) return; message = string.Format(message, args); if (ExecutingCmdlet != null) { if (msgType == EventLogEntryType.Warning) { ExecutingCmdlet.WriteWarning(message); } else if (msgType == EventLogEntryType.Error) { ExecutingCmdlet.WriteError(new System.Management.Automation.ErrorRecord(new Exception(message), null, System.Management.Automation.ErrorCategory.NotSpecified, null)); } ExecutingCmdlet.WriteVerbose(message); } else { if (msgType == EventLogEntryType.Warning && !message.ToUpper().StartsWith("WARNING:")) message = "WARNING: " + message; if (msgType != EventLogEntryType.Information || Verbose) { Console.WriteLine(message); } } if (!string.IsNullOrEmpty(LogFile)) File.AppendAllText(LogFile, message + "\r\n"); }
public static void WriteToEventLog(string sourceName, string logName, EventLogEntryType error, int eventID, string message) { try { SiAuto.Main.EnterMethod("Helper.WriteToEventLog"); /*--------- Your code goes here-------*/ using (EventLog elog = new EventLog()) { if (!EventLog.SourceExists(sourceName)) { EventLog.CreateEventSource(sourceName, logName); } elog.Source = sourceName; elog.EnableRaisingEvents = true; elog.WriteEntry(message, error, eventID); } /*------------------------------------*/ } catch (Exception ex) { SiAuto.Main.LogException(ex); //throw ex; } finally { SiAuto.Main.LeaveMethod("Helper.WriteToEventLog"); } }
private void Log(String msg, EventLogEntryType type) { if (msg.Length > 32766) EventLog.WriteEntry("XebraHandler", msg.Substring(0,32766), type); else EventLog.WriteEntry("XebraHandler", msg, type); }
public void WriteEntry(string message, EventLogEntryType type) { if (!isEnabled) return; switch (logType) { case LogType.EventLog: Log.WriteEntry(message, type); break; case LogType.TextLog: string filename = "log_" + DateTime.Now.ToString("yyyyMMdd") + ".txt"; try { if (!Directory.Exists(logPath)) Directory.CreateDirectory(logPath); File.AppendAllText(logPath + filename, DateTime.Now.ToLongTimeString() + " : " + type + " : " + message + Environment.NewLine); } catch (Exception) { Thread.Sleep(new TimeSpan(0, 0, 2)); try { if (!Directory.Exists(logPath)) Directory.CreateDirectory(logPath); File.AppendAllText(logPath + filename, DateTime.Now.ToLongTimeString() + " : " + type + " : " + message + Environment.NewLine); } catch (Exception) { } } break; default: break; } }
/// <summary> /// Saves the specified _content. /// </summary> /// <param name="_content">The _content.</param> /// <param name="_logType">Type of the _log.</param> /// <param name="param">The parameter.</param> /// <returns>Result.</returns> public Result Save(string _content, EventLogEntryType _logType, object param) { content = _content; logType = _logType; sqlConnection = (SqlConnection)param; return AddToSQLTable(); }
public void WriteEventLogEntry(string Message, EventLogEntryType type) { if(_eventLog!=null) _eventLog.WriteEntry(Message, type); else throw new Exception("Unable to write to event log : not initialized. \r\nMessage to write:\r\n" + Message); }
public EventlogListener(string protocol, string source, string category, EventLogEntryType[] types, string key, int value, IMonitoringChannel channel) { if (protocol == null) throw new ArgumentNullException("protocol"); if (key == null) throw new ArgumentNullException("key"); if (channel == null) throw new ArgumentNullException("channel"); this.key = key; this.value = value; this.channel = channel; this.types = types; this.protocol = protocol; this.source = source; this.category = category; try { this.Initialize(); } catch (ArgumentException exception) { throw new ArgumentException( exception.Message + " (" + protocol + ")", exception); } }
private static void Write(string message, EventLogEntryType type) { if (!EventLog.SourceExists(sSource)) EventLog.CreateEventSource(sSource, "Application"); EventLog.WriteEntry(sSource, message, type, eventID); }
private static void WriteEventLog(string source, string content, EventLogEntryType type) { try { if (!EventLog.SourceExists(source)) { EventLog.CreateEventSource(source, "ECCentral.Service"); } using (EventLog errorLog = new EventLog()) { errorLog.Source = source; errorLog.WriteEntry(content, type); } } catch (Exception ex) { try { using (EventLog log = new EventLog("Application", ".", "ECCentral.Service.Utility")) { log.WriteEntry(ex.ToString(), EventLogEntryType.Error); } } catch { } } }
/// <summary> /// Saves the specified _content. /// </summary> /// <param name="_content">The _content.</param> /// <param name="_logType">Type of the _log.</param> /// <returns>System.String.</returns> public Result Save(string _content, EventLogEntryType _logType) { content = _content; logType = _logType; logPath = @"C:\Cube\Logs\"; return AddToFile(); }
private void BaseWriteEntry(string message, EventLogEntryType logType, int eventId) { if (this.HasInitialized) { this.LoggerProxy.Process(new LogObject(message, logType, eventId)); } }
public static void Log(string message, EventLogEntryType logType, [CallerMemberName] string memberName = "", [CallerLineNumber] int lineNumber = 0) { try { using (StreamWriter log = new StreamWriter("logs.txt", true)) { string _out = $"[{DateTime.Now.ToString("dd/MM hh:mm")} {Enum.GetName(typeof(EventLogEntryType), logType)}] "; switch (logType) { case EventLogEntryType.SuccessAudit: case EventLogEntryType.FailureAudit: case EventLogEntryType.Warning: case EventLogEntryType.Error: _out += $"from `{memberName}' at {lineNumber}: {message}"; Console.WriteLine(_out); log.WriteLine(_out); log.Flush(); break; case EventLogEntryType.Information: _out += message; Console.WriteLine(_out); log.WriteLine(_out); log.Flush(); break; default: throw new ArgumentOutOfRangeException(nameof(logType), logType, null); } } } catch (Exception ex) { Console.WriteLine($"||| Logging error occured: {ex}", EventLogEntryType.Error); } }
public void Write(string msg, EventLogEntryType type) { Console.WriteLine(msg); // TODO: REBUILD //_log.WriteEntry(msg, type); }
/// <summary> /// Prints a message to the local systems eventlog. /// </summary> /// <param name="entry"></param> /// <param name="type"></param> private static void Print(string entry, EventLogEntryType type) { switch (type) { case EventLogEntryType.Error: entry = "[error]: " + entry; break; case EventLogEntryType.Information: entry = "[comment]: " + entry; break; case EventLogEntryType.Warning: entry = "[warning]: " + entry; break; } try { if (EventLog.Exists("Application", ".")) { EventLog eventLog = new EventLog("Application", ".", "EasyHook"); #if !DEBUG if(InType == EventLogEntryType.Error) #endif eventLog.WriteEntry(entry, type); } } catch { } #if DEBUG Console.WriteLine(entry); #endif }
public void WriteEvent(string eventSource, string message, EventLogEntryType eventType, int eventId) { }
internal static void _WriteFile(string message, EventLogEntryType type) { // If LogStreamWriter is not null (check inside the function) then write to file. Current.FileWriter.WriteLine(message); }
private void LogEvent(string msg, EventLogEntryType et, int id) { rtpSession.LogEvent("RtcpListener", msg, et, id); }
public EventInstance(long instanceId, int categoryId, EventLogEntryType entryType) : this(instanceId, categoryId) { EntryType = entryType; }
/// <summary> /// Writes an error entry to the Application log, Application Source. This is a fallback error writing mechanism. /// </summary> /// <param name="message">The error message.</param> /// <param name="errorType">Type of error.</param> /// <param name="ex">Original exception (optional)</param> public static string WriteToAppLog(string message, EventLogEntryType errorType, Exception ex = null) { message = GetErrorMessageString(message, ex); EventLog.WriteEntry("Application", message, errorType, 0); return(message); }
private static readonly LamedalCore_ _lamed = LamedalCore_.Instance; // system library /// <summary> /// Return the eventlog and filter it. /// </summary> /// <param name="filterLog">If [true] then filter the log</param> /// <param name="logName">The event log name</param> /// <param name="unique">if [true] then the list is unique</param> /// <param name="today">if [true] filter for today</param> /// <param name="eventFilterType">The event filter type</param> /// <returns></returns> public static List <EventLogEntry> EventLog(bool filterLog = true, enEventLog logName = enEventLog.system, bool unique = true, bool today = false, EventLogEntryType eventFilterType = EventLogEntryType.Error) { //var log = "application"; var log = logName.ToString(); var aLog = new EventLog(log, Environment.MachineName); //EventLogEntry entry; List <EventLogEntry> result = aLog.Entries.Cast <EventLogEntry>().ToList(); if (filterLog) { result = result.Where(x => x.EntryType == eventFilterType).ToList(); } if (today) { result = result.Where(x => _lamed.Types.DateTime.IsToday(x.TimeGenerated)).ToList(); } if (unique) { var uniqueList = new Dictionary <string, EventLogEntry>(); foreach (var entry in result) { _lamed.Types.Dictionary.Key_AddSafe(uniqueList, entry.Source, entry, enCompare_DuplicateAction.Ignore); result = uniqueList.Values.ToList(); } } return(result); }
void _updater_OnStatusUpdate(string text, EventLogEntryType elt) { notifyIcon.ShowBalloonTip(0, "Dynamic IP", text, elt == EventLogEntryType.Error ? ToolTipIcon.Error : ToolTipIcon.Info); }
/// <summary> /// Writes the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="eventLogType">Type of the event log.</param> private void Write(object message, EventLogEntryType eventLogType) { Write(message, null, eventLogType); }
/// <summary/> /// <param name="source"/> /// <param name="logType"/> /// <param name="eventId"/> /// <exclude/> public EventLogger(string source, EventLogEntryType logType, int eventId) { this.eventLog = new EventLog(SR.LogName, SR.MachineName, source); this.logType = logType; this.eventId = eventId; }
public void WriteToEventLog(Exception exception, EventLogEntryType eventLogEntryType) { var message = GetMessageFromException(exception); WriteToEventLog(message, eventLogEntryType); }
/// <summary> /// Запись сообщения в события Windows. /// </summary> /// <param name="message">Сообщение для записи в лог.</param> /// <param name="eventLogEntryType">Статус сообщения: ошибка, информация или др.</param> protected static void WriteToEventLog(string message, EventLogEntryType eventLogEntryType = EventLogEntryType.Information) { EventLog.WriteEntry(LogSourceName, message, eventLogEntryType); }
public VehicleEntity CreateVehicle(VehicleEntity newVehicle) { var resultVehicleEntity = new VehicleEntity(); EventLogEntryType eventLogType = EventLogEntryType.Information; try { #region Detailer Call var requestUri = ConfigurationManager.AppSettings["detailerUrl"]; dynamic detailerResponse = RestClient.PostData(requestUri, GetDetailerRequestPayload(newVehicle)); _logger.AppendMessages("Successfully completed Detailer call before Create Vehicle."); #endregion Detailer call #region Create Vehicle Call if (detailerResponse.vehicles != null && detailerResponse.vehicles.GetType() == typeof(JArray) && detailerResponse.vehicles[0] != null && detailerResponse.vehicles[0].vehicle != null) { JObject vehicleEntity = detailerResponse.vehicles[0].vehicle; vehicleEntity.Add("stockNumber", newVehicle.StockNumber ?? string.Empty); _logger.AppendMessages("Detailer found atleast one vehicle in response."); if (newVehicle.photoIds != null) { //?? _logger.AppendMessages("Number of PhotoIds: " + newVehicle.photoIds.Count()); //vehicleEntity.Add("assets", JObject.Parse("{\"dealerPhotos\": []}")); foreach (var id in newVehicle.photoIds) { if (id != null && !id.Equals(string.Empty) && !id.Equals(" ") && vehicleEntity.GetValue("assets") == null) { //?? _logger.AppendMessages("L"); vehicleEntity.Add("assets", JObject.Parse("{\"dealerPhotos\": [{\"id\":" + id + "}]}")); } } } if (vehicleEntity.GetValue("source") == null) { vehicleEntity.Add("source", "M"); } var createVehicleRequestPayload = string.Format("{{\"criteria\":{{\"vehicleContexts\":[{{\"vehicleContext\":{{\"vehicle\":{0},\"modifiedFields\":[\"assets\",\"bodyStyle\",\"bodyType\",\"certified\",\"colors.exterior.base\",\"colors.exterior.code\",\"colors.exterior.name\",\"colors.interior.code\",\"colors.interior.name\",\"createdDate\",\"descriptions\",\"doors\",\"drivetrain\",\"engine.aspiration\",\"engine.cylinders\",\"engine.description\",\"engine.displacement\",\"engine.fuelType\",\"engine.power\",\"id\",\"inventoryOwner\",\"lastModifiedDate\",\"lotDate\",\"make.Id\",\"make.label\",\"model.Id\",\"model.label\",\"odometer\",\"oemModelCode\",\"options.dealerOptions\",\"options.factoryOptions\",\"preOwned\",\"prices.discountPrice\",\"prices.internetPrice\",\"prices.invoicePrice\",\"prices.msrp\",\"prices.retailPrice\",\"prices.vendedPrice\",\"stockNumber\",\"style.Id\",\"style.trim\",\"transmission.speeds\",\"transmission.text\",\"transmission.type\",\"unmodifiable\",\"vin\",\"warranties\",\"year\"]}}}}],\"inventoryOwner\":\"gmps-kindred\",\"useSource\": true}}}}", vehicleEntity); _logger.AppendMessages(string.Format("Request payload for create vehicle call - {0}", createVehicleRequestPayload)); dynamic result = RestClient.PostData(ConfigurationManager.AppSettings["createVehicleUrl"], createVehicleRequestPayload); if (result != null && result.result != null) { result = result.result; if (result != null && result.status != null && result.status.GetType() == typeof(JArray) && result.status[0].vehicle != null) { _logger.AppendMessages(string.Format("Create Vehicle call successful . result {0} ", result)); resultVehicleEntity.Vin = result.status[0].vehicle.vin ?? string.Empty; resultVehicleEntity.StockNumber = result.status[0].vehicle.stockNumber ?? string.Empty; TryGetMake(result.status[0].vehicle, resultVehicleEntity); TryGetModel(result.status[0].vehicle, resultVehicleEntity); TryGetOemModelCode(result.status[0].vehicle, resultVehicleEntity); TryGetTrimAndStyle(result.status[0].vehicle, resultVehicleEntity); TryGetYear(result.status[0].vehicle, resultVehicleEntity); #region Get Color from response var refStyles = result.status[0].vehicle; if (refStyles.colors != null && refStyles.colors.GetType() == typeof(JArray)) { foreach (var iColor in refStyles.colors) { var color = iColor.color; var colorRefObject = new ColorReferenceEntity(); if (color.category != null && color.category == "Exterior") { resultVehicleEntity.ExternalColor = new Color { Code = color.code ?? string.Empty, //Base = color.exterior.base ?? string.Empty, Name = color.name ?? string.Empty, RgbHexCode = color.RGBHexCode ?? string.Empty }; } if (color.category != null && color.category == "Interior") { resultVehicleEntity.InternalColor = new Color { Code = color.code ?? string.Empty, //Base = color.exterior.base ?? string.Empty, Name = color.name ?? string.Empty, RgbHexCode = color.RGBHexCode ?? string.Empty }; } } } #endregion Get Color from response } } if (result.error != null && result.error.message != null) { _logger.AppendMessages("Create Vehicle call unsuccessful"); throw new Exception(result.error.message); } } #endregion Create Vehicle Call } catch (Exception ex) { eventLogType = EventLogEntryType.Error; _logger.AppendMessages(string.Format("Error - {0}.", ex)); } finally { _logger.LogAppendedMessages(eventLogType); } return(resultVehicleEntity); }
/// <summary> /// EventLog에 항목을 쓴다. /// </summary> /// <param name="message">로그엔트리 정보</param> /// <param name="entryType">엔트리 타입</param> public void WriteEntry(string message, EventLogEntryType entryType) { Log.WriteEntry(message, entryType); }
/// <summary> /// 지정된 <c>EventLogEntryType</c>(수준)과 같은 <c>EventLogEntry</c>를 검색한다. /// </summary> /// <param name="entryType">검색할 <c>EventLogEntryType</c>(수준)의 값</param> /// <returns>찾은 <c>EventLogEntry</c>의 컬렉션</returns> public IEnumerable <EventLogEntry> FindEntryByEntryType(EventLogEntryType entryType) { return(EventLogTool.FindEntryByEntryType(Log, entryType)); }
/// <summary> /// EventLog에 항목을 쓴다. /// </summary> /// <param name="message">로그엔트리 정보</param> /// <param name="entryType">엔트리 타입</param> /// <param name="eventID">이벤트 ID</param> /// <param name="category">분류 번호</param> public void WriteEntry(string message, EventLogEntryType entryType, int eventID, short category) { Log.WriteEntry(message, entryType, eventID, category); }
/// <summary> /// EventLog에 항목을 쓴다. /// </summary> /// <param name="message">로그엔트리 정보</param> /// <param name="entryType">엔트리 타입</param> /// <param name="eventID">이벤트 ID</param> public void WriteEntry(string message, EventLogEntryType entryType, int eventID) { Log.WriteEntry(message, entryType, eventID); }
/// <summary> /// The last error point /// </summary> public static void DirectEventViewerLog(string message, EventLogEntryType eventLogEntryType) { EventLog.WriteEntry("GrabCaster", message, eventLogEntryType, 0); }
/// <summary> /// EventLog에 항목을 쓴다. /// </summary> /// <param name="message"></param> /// <param name="entryType"></param> /// <param name="eventID"></param> /// <param name="category"></param> /// <param name="rawData"></param> public void WriteEntry(string message, EventLogEntryType entryType, int eventID, short category, byte[] rawData) { Log.WriteEntry(message, entryType, eventID, category, rawData); }
public void WriteEntry(string message, EventLogEntryType logType) { this.WriteEntry(message, logType, -2147483648); }
/// <summary> /// Writes the log entry into the Test Context /// </summary> /// <param name="category">The application specific category of the log entry.</param> /// <param name="title">The title for the log entry. This is usually the 1st thing that /// will be seen when entries are reviewed.</param> /// <param name="message">The full text of the message sent to the logging provider.</param> /// <param name="severity">An indication of how critical an event the entry represents.</param> /// <param name="entryType">The type of entry as described in the EventLogEntryType enumeration.</param> public override void Write(string category, string title, string message, int severity, EventLogEntryType entryType) { _testContext.WriteLine("Logger: {0} ({1}/{3}) - {2}\r\n", title, category, message, severity); }
/// <summary> /// Creates the log. /// </summary> /// <param name="_context">The _context.</param> /// <param name="_level">The _level.</param> public void CreateLog(string _content, EventLogEntryType _level) { ShowLog(_content); WriteLog(_content, _level); }
private void WriteLog(string msg, EventLogEntryType t, int id) { Log.WriteEntry(DateTime.Now.ToString() + " " + _dbg + " " + _ver + msg, t, id); }
/// <summary> /// WriteEntry method implementation /// </summary> public static void WriteEntry(string message, EventLogEntryType type, int eventID) { EventLog.WriteEntry(EventLogSource, message, type, eventID); }
private void WriteLog(string msg, EventLogEntryType eventType, int eventId) { EventLog.WriteEntry(serviceEventSource, msg, eventType, eventId); }
/// <summary> /// Writes to system event log /// </summary> /// <param name="logName">Sirona</param> /// <param name="sourceName">Application or module</param> /// <param name="entryMessage">message to log</param> /// <param name="logEntryType">Error, Warning, Information, SuccessAudit, FailureAudit</param> public static void WriteToEventLog(string logName, string sourceName, string entryMessage, EventLogEntryType logEntryType) { try { if ((!EventLog.SourceExists(sourceName))) EventLog.CreateEventSource(sourceName, "Sirona"); } catch (System.Security.SecurityException e) { sourceName = "Web Error"; } EventLog.WriteEntry(sourceName, entryMessage, logEntryType, 0); }
private static void WriteToEventLog(string eventText, EventLogEntryType entryType) { String source = "vstsAgentService"; EventLog.WriteEntry(source, eventText, entryType, 100); }
/// <summary> /// This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> /// method. /// </summary> /// <param name="loggingEvent">the event to log</param> /// <remarks> /// <para>Writes the event to the system event log using the /// <see cref="ApplicationName"/>.</para> /// /// <para>If the event has an <c>EventID</c> property (see <see cref="LoggingEvent.Properties"/>) /// set then this integer will be used as the event log event id.</para> /// /// <para> /// There is a limit of 32K characters for an event log message /// </para> /// </remarks> override protected void Append(LoggingEvent loggingEvent) { // // Write the resulting string to the event log system // int eventID = m_eventId; // Look for the EventID property object eventIDPropertyObj = loggingEvent.LookupProperty("EventID"); if (eventIDPropertyObj != null) { if (eventIDPropertyObj is int) { eventID = (int)eventIDPropertyObj; } else { string eventIDPropertyString = eventIDPropertyObj as string; if (eventIDPropertyString == null) { eventIDPropertyString = eventIDPropertyObj.ToString(); } if (eventIDPropertyString != null && eventIDPropertyString.Length > 0) { // Read the string property into a number int intVal; if (SystemInfo.TryParse(eventIDPropertyString, out intVal)) { eventID = intVal; } else { ErrorHandler.Error("Unable to parse event ID property [" + eventIDPropertyString + "]."); } } } } short category = m_category; // Look for the Category property object categoryPropertyObj = loggingEvent.LookupProperty("Category"); if (categoryPropertyObj != null) { if (categoryPropertyObj is short) { category = (short)categoryPropertyObj; } else { string categoryPropertyString = categoryPropertyObj as string; if (categoryPropertyString == null) { categoryPropertyString = categoryPropertyObj.ToString(); } if (categoryPropertyString != null && categoryPropertyString.Length > 0) { // Read the string property into a number short shortVal; if (SystemInfo.TryParse(categoryPropertyString, out shortVal)) { category = shortVal; } else { ErrorHandler.Error("Unable to parse event category property [" + categoryPropertyString + "]."); } } } } // Write to the event log try { string eventTxt = RenderLoggingEvent(loggingEvent); // There is a limit of about 32K characters for an event log message if (eventTxt.Length > MAX_EVENTLOG_MESSAGE_SIZE) { eventTxt = eventTxt.Substring(0, MAX_EVENTLOG_MESSAGE_SIZE); } EventLogEntryType entryType = GetEntryType(loggingEvent.Level); using (SecurityContext.Impersonate(this)) { EventLog.WriteEntry(m_applicationName, eventTxt, entryType, eventID, category); } } catch (Exception ex) { ErrorHandler.Error("Unable to write to event log [" + m_logName + "] using source [" + m_applicationName + "]", ex); } }
public static void WriteLogEntryWeb(EventLogEntryType type, string message, params object[] args) { Helper.WriteLogEntry("Seal Web Server", type, message, args); }
public static void WriteEvent(TSEventLogEventType tsEventLogEventType, HttpRequest httpRequest = null, User user = null, Organization organization = null, string[] extraInfo = null) { try { string source = "TeamSupport"; if (EventLog.SourceExists(source)) { List <object> prams = extraInfo == null ? new List <object>() : new List <object>(extraInfo); EventLogEntryType eventLogEntryType = EventLogEntryType.Information; switch (tsEventLogEventType) { case TSEventLogEventType.LoginSuccess: prams.Add("User logged in"); eventLogEntryType = EventLogEntryType.SuccessAudit; break; case TSEventLogEventType.LogoutSuccess: prams.Add("User logged out"); eventLogEntryType = EventLogEntryType.SuccessAudit; break; case TSEventLogEventType.FailedLoginAttempt: prams.Add("Failed log in attempt"); eventLogEntryType = EventLogEntryType.FailureAudit; break; case TSEventLogEventType.AccountLocked: prams.Add("Account locked out"); eventLogEntryType = EventLogEntryType.Warning; break; default: break; } if (httpRequest != null) { prams.Add(string.Format("IPAddress: {0}", httpRequest.UserHostAddress)); } if (organization != null) { prams.Add(string.Format("OrganizationID: {0}", organization.OrganizationID.ToString())); prams.Add(string.Format("Account: {0}", organization.Name)); } if (user != null) { prams.Add(string.Format("UserID: {0}", user.UserID.ToString())); prams.Add(string.Format("User: {0}", user.FirstLastName)); prams.Add(string.Format("Email: {0}", user.Email)); } EventLog.WriteEvent(source, new EventInstance((int)tsEventLogEventType, 0, eventLogEntryType), prams.ToArray()); //EventLog.WriteEntry(source, message, eventLogEntryType, (int)tsEventLogEventType, (short)tsEventLogCategoryType); } else { // ExceptionLogs.AddLog(LoginUser.Anonymous, "TeamSupport has not been setup as a source in the event logs."); } } catch (Exception ex) { ExceptionLogs.LogException(LoginUser.Anonymous, ex, "Event Logs", "Error writing event log"); } }
/// <summary> /// Ignoes the Event message. /// </summary> /// <param name="eventId">The event id to assocuiate with the message.</param> /// <param name="eventType">The event type to associate with the message.</param> /// <param name="message">The message.</param> public void WriteEvent(int eventId, EventLogEntryType eventType, string message) { }