public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int blockId, int delta, CancellationToken cancellationToken) { var kvLogMessage = logMessage as KeyValueLogMessage; if (kvLogMessage == null) { return; } try { // guard us from exception thrown by telemetry var telemetryEvent = CreateTelemetryEvent(functionId, End); SetBlockId(telemetryEvent, functionId, blockId); var durationName = functionId.GetPropertyName(Duration); telemetryEvent.SetIntProperty(durationName, delta); var cancellationName = functionId.GetPropertyName(CancellationRequested); telemetryEvent.SetBoolProperty(cancellationName, cancellationToken.IsCancellationRequested); _session.PostEvent(telemetryEvent); } catch { } }
/// <summary> /// Processes the specified log message /// </summary> /// <param name="message"></param> protected override void ProcessMessage(LogMessage message) { // Call base base.ProcessMessage(message); // Transform log type and strip the tag Imports.OxideNative_LogType logType; string msg; switch (message.Type) { case LogType.Debug: logType = Imports.OxideNative_LogType.Debug; msg = message.Message.Replace(" [Debug]", ":"); break; case LogType.Info: logType = Imports.OxideNative_LogType.Info; msg = message.Message.Replace(" [Info]", ":"); break; case LogType.Warning: logType = Imports.OxideNative_LogType.Warning; msg = message.Message.Replace(" [Warning]", ":"); break; case LogType.Error: logType = Imports.OxideNative_LogType.Error; msg = message.Message.Replace(" [Error]", ":"); break; default: return; } // Forward it to native Imports.OxideNative_WriteLog(logType, msg); }
/// <summary> /// Fail safe UserLog gate to write internal exception without main logging context, but with max guarantee of regestering /// synchronous /// </summary> public void LogFailSafe(LogMessage message) { if (null == message) { return; } if (string.IsNullOrEmpty(message.Name)) { message.Name = "FAILSAFE"; } try { StreamWriter wr = null; for (var i = 0; i < 100; i++) { try { wr = new StreamWriter(Path.Combine(EnvironmentInfo.RootDirectory, "failsafelog" + i + ".txt"), true, Encoding.UTF8); break; } // ReSharper disable EmptyGeneralCatchClause catch (Exception) {} // ReSharper restore EmptyGeneralCatchClause } if (null == wr) { var tmpfile = Path.GetTempFileName() + ".failsafelog." + DateTime.Now.ToString("yyyy-MM-dd-hh-mm-ss", CultureInfo.InvariantCulture) + ".txt"; wr = new StreamWriter(tmpfile, true, Encoding.UTF8); } using (wr) { wr.WriteLine(message.ToString()); wr.Flush(); } } catch (Exception ex) { throw new LogException("even safe mode fails to be executed", ex); } }
public static void Log(string input) { var endpoint = GlobalHost.ConnectionManager.GetConnectionContext<ExecuteEndPoint>().Connection; var logMessage = new LogMessage(input); endpoint.Broadcast(logMessage); }
private static void RegisterDiagnostics(ContainerBuilder builder) { builder.Register( c => { var loggers = c.Resolve<IEnumerable<ILogger>>(); Action<LevelToLog, string> action = (p, s) => { var msg = new LogMessage(p, s); foreach (var logger in loggers) { try { logger.Log(msg); } catch (NLogRuntimeException) { // Ignore it and move on to the next logger. } } }; return new SystemDiagnostics(action, null); }) .As<SystemDiagnostics>() .SingleInstance(); }
/// <summary> /// Возвращет форматированный текст из представления сообщения <see cref="LogMessage"/> /// </summary> /// <param name="message">Представление сообщения <see cref="LogMessage"/></param> /// <returns>Форматированная строка сообщения</returns> protected virtual string GetFormatted(LogMessage message) { string text; if (!string.IsNullOrEmpty(CustomFormat)) { text = Regex.Replace(CustomFormat, @"\$\{(\w+)\}", m => { var propName = m.Groups[1].Value; var prop = message.GetType().GetProperty(propName); if (null != prop) { var val = prop.GetValue(message, null); if (null == val) { return ""; } if (val is DateTime) { return ((DateTime) val).ToString("yyyy-MM-dd HH:mm:ss"); } return val.ToString(); } return ""; }); } else { text = message.ToString(); } return text; }
public ErrLog(string msg, string location, string state, LogMessage originalMessage) { ErrorMessage = msg; ParserState = state; ErrorLocation = location; LogData = originalMessage; }
public void Log(LogMessage message) { lock (_lock) { _wrappedLog.Log(message); } }
public override void Log ( LogMessage message ) { Colorize( message.MessageType ); GetWriter( message.MessageType ).WriteLine("{2}", message.DateTime, message.ThreadId, message.MessageText ); Console.ResetColor(); }
/// <summary> /// Creates a log message from the specified arguments /// </summary> /// <param name="type"></param> /// <param name="format"></param> /// <param name="args"></param> /// <returns></returns> protected LogMessage CreateLogMessage(LogType type, string format, object[] args) { LogMessage msg = new LogMessage { Type = type, Message = $"{DateTime.Now.ToShortTimeString()} [{type}] {format}" }; if (args.Length != 0) msg.Message = string.Format(msg.Message, args); return msg; }
/// <summary> /// Writes a message to this logger /// </summary> /// <param name="msg"></param> internal virtual void Write(LogMessage msg) { // If we're set to process immediately, do so, otherwise enqueue if (processmessagesimmediately) ProcessMessage(msg); else messagequeue.Enqueue(msg); }
/// <summary> /// /// </summary> /// <param name="logmessage"></param> public override void Write(LogMessage logmessage) { base.Write(logmessage); if (logmessage.Level >= this.Level){ Messages.Add(logmessage); } }
public void saveLog(LogLevel logLevel, string message) { LogMessage n = new LogMessage (logLevel, message); if (_messages.Count >= max) { _messages.RemoveAt (0); } _messages.Add (n); }
/// <summary> /// Record the log message to the console. /// </summary> /// <param name="logMessage">The log message object to record</param> protected internal override void Log(LogMessage logMessage) { if (logMessage == null) return; DateTime time = DateTime.FromBinary(logMessage.Time); String level = Enum.GetName(typeof(LogLevel), logMessage.Level); Console.WriteLine(OutputFormat, time, level, logMessage.Tag, logMessage.Message); }
public static void Display(LogMessage message) { writeTimePrefix(); writeTypePrefix(message.LogType, message.BGColor, message.FGColor); for (int i = 0; i < 40 - message.Message.Length; i++) message.Message += " "; Console.WriteLine(message.Message); }
/// <summary> /// </summary> /// <param name="message"> </param> protected override void InternalWrite(LogMessage message) { var resolvedFileName = GetResolvedFileName(message); var text = ""; text = GetText(message); using (var sw = new StreamWriter(resolvedFileName, true, Encoding.UTF8)) { sw.WriteLine(text); sw.Flush(); } }
/// <summary> /// ¬нутренн¤¤ операци¤ записи в лог /// </summary> /// <param name="message">“екст сообщени¤ в формате <see cref="LogMessage"/></param> protected override void InternalWrite(LogMessage message) { if (null == _writer) { return; } var text = GetText(message); _writer.WriteLine(text); _writer.Flush(); }
static void WriteLine(LogMessage message, ConsoleColor color) { Console.ForegroundColor = color; Console.WriteLine(message.Message); if (message.Exception != null) Console.WriteLine(message.Exception); Console.ResetColor(); }
bool Filter(LogMessage m) { if ((m.Type == LogType.Debug && showDebug) || (m.Type == LogType.Error && showErrors) || (m.Type == LogType.Metrics && showMetrics) || (m.Type == LogType.Warning && showWarnings)) return true; return false; }
public void CanParseDelayedMessage() { var logFile = @"00:26 [2013-12-24 00:15] < Nightmare Moon> BEEP BEEP MOTHERFUCKERS!!!"; var expected = new LogMessage(new DateTime(2013, 12, 24, 0, 15, 0), "Nightmare Moon", "BEEP BEEP MOTHERFUCKERS!!!"); var logMessage = new LogParser().Parse(logFile).Single(); Assert.Equal(expected, logMessage); }
/// <summary> /// Регистрирует сообщения /// </summary> /// <param name="message"></param> public LogMessage Register(LogMessage message){ if (_config.ContainsKey(message.Code)){ return ProcessConfigured(message,_config[message.Code]); } else{ _log.Add(message); return message; } }
public override void Log ( LogMessage message ) { Colorize( message.MessageType ); GetWriter( message.MessageType ).WriteLine("[{0:HH:mm:ss}] {1}> : {2}", message.DateTime, message.ThreadId, message.MessageText ); //GetWriter( message.MessageType ).WriteLine("{1,2}| {2}", message.DateTime, message.ThreadId, message.MessageText ); Console.ResetColor(); }
public LogException(LogMessage msg) { Msg = msg; try { Data["Severity"] = msg.Severity; // Disabled because members of the Data dictionary must be serializable, // but msg.Context might not be. We could convert to string, but is it // worth the performance cost? Loyc code isn't really using Data anyway. //Data["Context"] = msg.Context; } catch { } }
public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int uniquePairId, int delta, CancellationToken cancellationToken) { if (!_pendingActivities.TryRemove(uniquePairId, out var activity)) { Contract.Requires(false, "when can this happen?"); return; } activity.Dispose(); }
protected string StringifyLogMessage(LogMessage logMessage) { var sb = new StringBuilder(); sb.AppendFormat("{0}: {1}", logMessage.LogType, logMessage.Message).AppendLine(); if (logMessage.Uri != null) sb.AppendFormat("\tUri: ").Append(logMessage.Uri).AppendLine(); if (logMessage.Exception != null) sb.AppendFormat("\tException: ").Append(logMessage.Exception).AppendLine(); return sb.ToString(); }
public void ItFormatsTimestampsAsExpected() { var logMessage = new LogMessage { Message = "Hello, world!", }; var jsonMessage = logMessage.ToString(); var dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonMessage); var regex = new Regex(@"\d+\.\d{9}"); StringAssert.Matches(dictionary["timestamp"], regex); }
public void Construct(ILogger logger, FunctionId functionId, LogMessage logMessage, int blockId, CancellationToken cancellationToken) { this.logger = logger; this.functionId = functionId; this.logMessage = logMessage; this.tick = Environment.TickCount; this.blockId = blockId; this.cancellationToken = cancellationToken; logger.LogBlockStart(functionId, logMessage, blockId, cancellationToken); }
public void Publish(LogMessage logMessage) { if (cleanOutput) { Console.WriteLine(logMessage.Text); } else { Console.WriteLine(_loggerFormatter.ApplyFormat(logMessage)); } }
public void AddMessage(LogMessage message) { if (InvokeRequired) { Invoke(new Action(delegate { AddMessage(message); })); return; } if (Filter(message)) { list.Items.Add(MakeItem(message)); ScrollToEnd(); } }
public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int uniquePairId, int delta, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { RoslynEventSource.Instance.BlockCanceled(functionId, delta, uniquePairId); } else { RoslynEventSource.Instance.BlockStop(functionId, delta, uniquePairId); } }
/// <summary> /// Selects the given <paramref name="message"/>. /// </summary> /// <param name="message">The <see cref="LogMessage"/> o select</param> public bool SelectLogMessage(LogMessage message) { // There is no select message support for the logger tree. return(true); }
private Task Log(LogMessage message) { Debug.Log(message.Message); return(Task.CompletedTask); }
public virtual void AfterLog(LogMessage logMessage) { }
private Task LogFromBot(LogMessage msg) { Log.Info(msg.ToString()); return(Task.CompletedTask); }
private Task OnLogAsync(LogMessage msg) => PrettyConsole.LogAsync(msg.Severity, msg.Source, msg.Message);
public static void Log(LogMessage message) { Action?.Invoke($"State: {message.IsSuccess}, Message: {message.Message}"); }
/// <summary> /// Processes the specified message /// </summary> /// <param name="message"></param> protected virtual void ProcessMessage(LogMessage message) { }
private Task LogAsync(LogMessage logMessage) { Console.WriteLine(logMessage.Message); return(Task.CompletedTask); }
protected void Log(string msg) { Log(LogMessage.Info(msg)); }
private Task LogAsync(LogMessage Log) { Console.WriteLine(Log.ToString()); return(Task.CompletedTask); }
private async Task Log(LogMessage msg) { Console.WriteLine(msg.Message); }
private Task Log(LogMessage msg) { Console.WriteLine(msg.ToString()); return(Task.CompletedTask); }
public async Task Log(LogMessage message) { await objDb.Log(message); }
public abstract Task <int> Write(LogMessage message);
public void GetWarningMessage_NullMessage_DoesNotThrowException(string message) { LogMessage log = new LogMessage(message); Assert.DoesNotThrow(() => log.GetWarningMessage()); }
public LogMessageEventArgs(LogMessage logMessage) { LogMessage = logMessage; }
public override async Task LogAsync(LogMessage logMessage) { Console.WriteLine(logMessage.ToString()); await Task.CompletedTask; }
private async Task LogAsync(LogMessage logMessage) { await _logService.LogAsync(logMessage); }
private static Task AnnouncerLog(LogMessage msg) { Console.WriteLine($"{msg} [Announcer]"); return(Task.CompletedTask); }
public ForwardingLogger(string categoryName, LogMessage logAction) { _categoryName = categoryName; _logAction = logAction; }
/// <summary> /// Selects the given <paramref name="message"/>. /// </summary> /// <param name="message">The <see cref="LogMessage"/> o select</param> /// <returns><c>True</c> if the given <paramref name="message"/> was selected successfully, otherwise <c>false</c>.</returns> public bool SelectLogMessage(LogMessage message) { // Nothing to do here. return(true); }
public void Run() { Task.Run(async() => { LogMessage LogDownstreamText(LogEventLevel level, string text = null) => LogMessage.Downstream(level, Id, _downstreamClient.Endpoint.Address, text); LogMessage LogDownstreamException(Exception exception) => LogMessage.Downstream(exception, Id, _downstreamClient.Endpoint.Address); LogMessage LogUpstreamText(LogEventLevel level, string text = null) => LogMessage.Upstream(level, Id, _upstreamServer.Endpoint.Address, text); LogMessage LogUpstreamException(Exception exception) => LogMessage.Upstream(exception, Id, _upstreamServer.Endpoint.Address); LogMessage LogForwardProxyText(LogEventLevel level, string text = null) => LogMessage.ForwardProxy(level, Id, _upstreamServer.Endpoint.Address, text); LogMessage LogForwardProxyException(Exception exception) => LogMessage.ForwardProxy(exception, Id, _upstreamServer.Endpoint.Address); RequestLine requestLine; IEnumerable <Header> headers; HostHeader hostHeader; try { (GetRequestLineResult result, RequestLine requestLine)getRequestLineResult = _downstreamClient.GetRequestLine(); switch (getRequestLineResult.result) { case GetRequestLineResult.Success: requestLine = getRequestLineResult.requestLine; break; case GetRequestLineResult.InvalidRequestLine: LogDownstreamText(LogEventLevel.Error, "Invalid request line").Write(); goto close; default: throw new ArgumentOutOfRangeException(); } (GetHeadersResult result, IEnumerable <Header> headers)getHeadersResult = _downstreamClient.GetHeaders(); getHeadersResult.headers = getHeadersResult.headers ?? Enumerable.Empty <Header>(); switch (getHeadersResult.result) { case GetHeadersResult.Success: headers = getHeadersResult.headers.ToImmutableArray(); break; case GetHeadersResult.InvalidHeader: LogDownstreamText(LogEventLevel.Error, "Invalid header").Write(); goto close; default: throw new ArgumentOutOfRangeException(); } hostHeader = HostHeader.Parse(getHeadersResult.headers.FirstOrDefault(x => x.Name.Equals("Host", StringComparison.OrdinalIgnoreCase))); LogDownstreamText(LogEventLevel.Information).RightArrow(true).Text($"{getRequestLineResult.requestLine}{(hostHeader != null ? $", {hostHeader}" : "")}").Write(); } catch (Exception exception) { LogDownstreamException(exception).Write(); goto close; } bool isTunnel = requestLine.Method == "CONNECT"; string upstreamHost; int upstreamPort; if (requestLine.ParsedRequestUri.IsAbsoluteUri && _validAbsoluteUriSchemes.Contains(requestLine.ParsedRequestUri.Scheme, StringComparer.OrdinalIgnoreCase)) { upstreamHost = requestLine.ParsedRequestUri.Host; upstreamPort = requestLine.ParsedRequestUri.Port; } else if (hostHeader != null) { upstreamHost = hostHeader.Host; upstreamPort = hostHeader.Port ?? (isTunnel ? 443 : 80); } else { LogDownstreamText(LogEventLevel.Error, "Missing Host header").Write(); goto close; } if (_disallowedHosts.Any(x => x.Contains(upstreamHost) == ContainsResult.Yes)) { LogDownstreamText(LogEventLevel.Error, $"Host '{upstreamHost}' is disallowed").Write(); goto close; } ConfigModel.ForwardProxiesModel.ForwardProxyModel forwardProxy = isTunnel ? _forwardProxyHttps : _forwardProxyHttp; async Task <bool> ConnectToUpstreamServerAsync() { _upstreamServer?.Close(); var upstreamServer = new TcpClient(); try { if (forwardProxy != null && _noProxyHosts.All(x => x.Contains(upstreamHost) != ContainsResult.Yes)) { await upstreamServer.ConnectAsync(forwardProxy.Host, forwardProxy.Port); } else { forwardProxy = null; await upstreamServer.ConnectAsync(upstreamHost, upstreamPort); } } catch (Exception exception) { LogDownstreamException(exception).Write(); return(false); } _upstreamServer = _httpClientFactory.Create(upstreamServer); return(true); } if (!await ConnectToUpstreamServerAsync()) { goto close; } if (isTunnel) { var responseStatusLine = new ResponseStatusLine(requestLine.HttpVersion, 200); _downstreamClient.WriteResponseStatusLine(responseStatusLine); if (_configService.Config.Options.SendProxyAgentHeader) { _downstreamClient.WriteHeader("Proxy-Agent", typeof(Program).Namespace); } _downstreamClient.WriteNewLine(); _downstreamClient.Flush(); LogDownstreamText(LogEventLevel.Information).LeftArrow(true).Text(responseStatusLine.ToString()).Write(); if (forwardProxy != null) { LogForwardProxyText(LogEventLevel.Information).LeftArrow(true).Text($"{requestLine}{(hostHeader != null ? $", {hostHeader}" : "")}").Write(); _upstreamServer.WriteRequestLine(requestLine); _upstreamServer.WriteHeaders(hostHeader); _upstreamServer.WriteNewLine(); (GetResponseStatusLineResult result, ResponseStatusLine responseStatusLine)responseStatusLineResult = _upstreamServer.GetResponseStatusLine(); switch (responseStatusLineResult.result) { case GetResponseStatusLineResult.Success: LogForwardProxyText(LogEventLevel.Information).RightArrow(true).Text(responseStatusLineResult.responseStatusLine.ToString()).Write(); break; case GetResponseStatusLineResult.InvalidResponseStatusLine: LogForwardProxyText(LogEventLevel.Error, "Invalid response status line").Write(); break; default: throw new ArgumentOutOfRangeException(); } _upstreamServer.GetHeaders(); } } else { void WriteUpstreamServerRequest(params Header[] additionalHeaders) { _upstreamServer.WriteRequestLine(requestLine); _upstreamServer.WriteHeaders(headers); if (_configService.Config.Options.SendProxyAgentHeader) { _upstreamServer.WriteHeaders(Header.Parse($"Proxy-Agent: {typeof(Program).Namespace}")); } _upstreamServer.WriteHeaders(additionalHeaders); _upstreamServer.WriteNewLine(); _upstreamServer.Flush(); } WriteUpstreamServerRequest(); if (forwardProxy != null && forwardProxy.Authentication.Basic.Enabled) { (GetResponseStatusLineResult result, ResponseStatusLine responseStatusLine)getResponseStatusLineResult = _upstreamServer.GetResponseStatusLine(); switch (getResponseStatusLineResult.result) { case GetResponseStatusLineResult.Success: break; case GetResponseStatusLineResult.InvalidResponseStatusLine: LogUpstreamText(LogEventLevel.Error, "Invalid response line"); goto close; default: throw new ArgumentOutOfRangeException(); } if (getResponseStatusLineResult.responseStatusLine.StatusCode == 407) { (GetHeadersResult result, IEnumerable <Header> headers)getHeadersResult = _upstreamServer.GetHeaders(); switch (getHeadersResult.result) { case GetHeadersResult.Success: break; case GetHeadersResult.InvalidHeader: LogUpstreamText(LogEventLevel.Error, "Invalid header").Write(); goto close; default: throw new ArgumentOutOfRangeException(); } LogForwardProxyText(LogEventLevel.Warning).RightArrow(true).Text(getResponseStatusLineResult.responseStatusLine.ToString()).Write(); if (!await ConnectToUpstreamServerAsync()) { goto close; } (GetCredentialsResult result, string username, string clearTextPassword)getCredentialsResult = _credentialService.GetCredentials(); string base64Credential = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{getCredentialsResult.username}:{getCredentialsResult.clearTextPassword}")); LogForwardProxyText(LogEventLevel.Warning).LeftArrow(true).Text("Proxy authorization").Write(); WriteUpstreamServerRequest(new Header("Proxy-Authorization", $"Basic {base64Credential}")); } else { _downstreamClient.WriteResponseStatusLine(getResponseStatusLineResult.responseStatusLine); } } } var manualResetEvent = new ManualResetEventSlim(); #pragma warning disable 4014 Task.Run(() => #pragma warning restore 4014 { try { while (true) { ArraySegment <byte> arraySegment = _downstreamClient.Read(); if (arraySegment.Count == 0) { break; } _upstreamServer.Write(arraySegment); _upstreamServer.Flush(); LogDownstreamText(LogEventLevel.Verbose) .RightArrow(true) .Text($"{arraySegment.Count} byte{(arraySegment.Count == 1 ? "" : "s")}") .RightArrow(true) .UpstreamIdentifier(Id) .Space() .BracketedIpAddress(_upstreamServer.Endpoint.Address) .Write(); } } catch (Exception exception) { LogDownstreamException(exception).Write(); } finally { manualResetEvent.Set(); } }); #pragma warning disable 4014 Task.Run(() => #pragma warning restore 4014 { try { while (true) { ArraySegment <byte> arraySegment = _upstreamServer.Read(); if (arraySegment.Count == 0) { break; } _downstreamClient.Write(arraySegment); _downstreamClient.Flush(); (forwardProxy != null ? LogForwardProxyText(LogEventLevel.Verbose) : LogUpstreamText(LogEventLevel.Verbose)) .RightArrow(true) .Text($"{arraySegment.Count} byte{(arraySegment.Count == 1 ? "" : "s")}") .RightArrow(true) .DownstreamIdentifier(Id) .Space() .BracketedIpAddress(_downstreamClient.Endpoint.Address) .Write(); } } catch (Exception exception) { (forwardProxy != null ? LogForwardProxyException(exception) : LogUpstreamException(exception)).Write(); } finally { manualResetEvent.Set(); } }); manualResetEvent.Wait(); close: CloseConnections(); LogDownstreamText(LogEventLevel.Information, "Connection closed").Write(); _closedByClient.OnNext(Unit.Default); }); }
/// <summary> /// 初始化Ip格式器 /// </summary> /// <param name="message">日志消息</param> public IpFormatter(LogMessage message) : base(message) { }
private Task CommandsOnLog(LogMessage logMessage) { return(HandleErrorAsync(logMessage)); }
private void AddLogEntries(List <LogEntry> entries, bool bypassClearingLog = false) { if (!bypassClearingLog && _isClearingLog) { return; } _dispatcherService.BeginInvoke(() => { var filteredLogEntries = new List <LogEntry>(); var typeNames = TypeNames; var requireSorting = false; lock (_lock) { using (SuspendChangeNotifications()) { using (_logEntries.SuspendChangeNotifications()) { foreach (var entry in entries) { _logEntries.Add(entry); if (IsValidLogEntry(entry)) { filteredLogEntries.Add(entry); } var targetTypeName = entry.Log.TargetType.Name; if (!typeNames.Contains(targetTypeName)) { try { typeNames.Add(targetTypeName); requireSorting = true; } catch (Exception) { // we don't have time for this, let it go... } } } } } } UpdateEntriesCount(entries); if (requireSorting) { lock (_lock) { using (typeNames.SuspendChangeNotifications()) { typeNames.Sort(); typeNames.Remove(DefaultComboBoxItem); typeNames.Insert(0, DefaultComboBoxItem); } } } LogMessage.SafeInvoke(this, new LogEntryEventArgs(entries, filteredLogEntries)); }); }
private async Task client_log(LogMessage message) { Console.WriteLine($"{DateTime.Now} at {message.Source} {message.Message}"); }
public void Publish(LogMessage logMessage) { Console.WriteLine(DefaultLoggerFormatter.ApplyFormat(logMessage)); }
public List <RequiredDocuments> GetAllRequiredDocumentsByTravelId(string travelRequestId, int badgeNumber) { List <RequiredDocuments> result = new List <RequiredDocuments>(); try { using (dbConn = ConnectionFactory.GetOpenDefaultConnection()) { for (int i = 1; i < 6; i++) { result.Add(new RequiredDocuments() { DocumentNumber = i, TravelRequestId = travelRequestId, FileName = string.Empty, DocumentName = string.Empty, Visible = (i == 1 || i == 2) ? true : false }); } string query = string.Format("Select CASHADVANCE from TRAVELREQUEST_ESTIMATEDEXPENSE where TRAVELREQUESTID = {0} AND CASHADVANCE > 0 ", travelRequestId); OracleCommand command = new OracleCommand(query, (OracleConnection)dbConn); command.CommandText = query; DbDataReader dataReader = command.ExecuteReader(); if (dataReader != null) { while (dataReader.Read()) { result.FirstOrDefault(p => p.DocumentNumber == 3).Visible = true; } } dataReader.Close(); command.Dispose(); string query2 = string.Format("Select TOTALESTIMATEDREGISTRATION from TRAVELREQUEST_ESTIMATEDEXPENSE where TRAVELREQUESTID = {0} AND TOTALESTIMATEDREGISTRATION > 0 ", travelRequestId); OracleCommand command2 = new OracleCommand(query2, (OracleConnection)dbConn); command2.CommandText = query2; DbDataReader dataReader2 = command2.ExecuteReader(); if (dataReader2 != null) { while (dataReader2.Read()) { result.FirstOrDefault(p => p.DocumentNumber == 4).Visible = true; } } dataReader2.Close(); command2.Dispose(); string query1 = string.Format("Select TRAVELREQUESTID, FILENAME, REQUIREDORDER from Travel_Uploads where TRAVELREQUESTID = {0} and Requiredorder is not null ", travelRequestId); OracleCommand command1 = new OracleCommand(query1, (OracleConnection)dbConn); command1.CommandText = query1; DbDataReader dataReader1 = command1.ExecuteReader(); if (dataReader1 != null) { while (dataReader1.Read()) { result.FirstOrDefault(p1 => p1.DocumentNumber == Convert.ToInt32(dataReader1["REQUIREDORDER"])).FileName = dataReader1["FILENAME"].ToString(); } } dataReader1.Close(); command1.Dispose(); dbConn.Close(); dbConn.Dispose(); return(result); } } catch (Exception ex) { LogMessage.Log("DocumentRepository : GetAllDocumentsByTravelId - returns required documents" + ex.Message); throw new Exception("Couldn't retrieve all the documents by travel id"); } }
private void Log(string message) { Log(LogMessage.Info(message)); }
public ForwardingLoggerProvider(LogMessage logAction) { _logAction = logAction; }