public override (double l1, double l2, double l3) Get() { var avg = _measurements.CalculateAggregatedAverageUsage(); if (avg.nrOfDataPoints < MinimumDataPoints) { return(-1, -1, -1); } Logger?.LogInformation($"avg current {avg.averageUsage} and charging at {avg.averageCharge}"); var chargeCurrent = Math.Round(LimitCurrentSolar(avg.averageCharge, avg.averageUsage), 2); bool stateHasChanged; if (chargeCurrent < MinimumChargeCurrent) { (chargeCurrent, stateHasChanged) = NotEnoughOverCapicity(); } else { var t = AllowToCharge(); if (t.changed) { LoggerState?.Info($"charging {chargeCurrent}"); } if (!t.allow) { chargeCurrent = 0.0f; } } return((float)Math.Round(chargeCurrent, 2), 0, 0); }
private void addImageAccordingToErrorLevel(LoggerState errorLevel, LogMessage @log) { if (errorLevel == LoggerState.INFORMATION) { string full = Path.GetFullPath(m_InformationImagePath); log.Image = full; } if (errorLevel == LoggerState.WARNING) { string full = Path.GetFullPath(m_WarningImagePath); log.Image = full; } if (errorLevel == LoggerState.ERROR) { string full = Path.GetFullPath(m_ErrorImagePath); log.Image = full; } if (errorLevel == LoggerState.CRITICAL) { string full = Path.GetFullPath(m_CriticalImagePath); log.Image = full; } }
static HospitalLogger() { Log = LogManager.GetLogger(typeof (HospitalLogger)); Logger = (log4net.Repository.Hierarchy.Logger) Log.Logger; _loggerLevel = LoggerState.All; AppendersTypes = new List<Type>(); }
static HospitalLogger() { Log = LogManager.GetLogger(typeof(HospitalLogger)); Logger = (log4net.Repository.Hierarchy.Logger)Log.Logger; _loggerLevel = LoggerState.All; AppendersTypes = new List <Type>(); }
public async Task Invoke(HttpContext context) { if (context == null) { throw new System.ArgumentNullException(nameof(context)); } string correlationId = GetOrAddCorrelationHeader(context); try { var loggerState = new LoggerState { [CORRELATION_ID_HEADER_NAME] = correlationId //Add any number of properties to be logged under a single scope }; using (_logger.BeginScope(loggerState)) { await next(context); } } //do not loose the scope in case of an unexpected error catch (Exception ex) when(LogOnUnexpectedError(ex)) { throw; } }
void Log(string message, LoggerState state = LoggerState.Info) { if (Logger != null) { Logger("ValueFinder", new AlgorithmLibEventArgs(state, message)); } }
///<summary> /// Logs message if the state provided matches its current state. ///</summary> public void Log(string message, LoggerState state) { if ((state & CurrentState) != CurrentState || state == LoggerState.Silent) { return; } WriteTo.WriteLine(message); }
public void Clear() { _startPosition = -Vector3.one; _movingPiece = null; _endPosition = -Vector3.one; _capturedPiece = null; _state = LoggerState.IDLE; }
/// <summary> /// Closes this logger. /// </summary> public static void Close() { if (state == LoggerState.Closed) { throw new InvalidOperationException("Can't close the log, because it is already closed!"); } log.Close(); stream.Close(); state = LoggerState.Closed; }
// public methods... /// <summary> /// Opens this logger using the given log file path. /// </summary> /// <param name="path">The path to the log file to use.</param> public static void Open(string path) { if (state == LoggerState.Opened) { throw new InvalidOperationException("Can't open the log, because it is already opened!"); } stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite); log = new StreamWriter(stream); state = LoggerState.Opened; }
/// <summary>Begins logging.</summary> public static void StartLogger() { if (currentLogger != null) { Destroy(currentLogger); } GameObject loggerObject = new GameObject("Performance Logger"); currentLogger = loggerObject.AddComponent <PerformanceLogger>(); CurrentState = LoggerState.Logging; }
public void MapClassString() { Demo d = new Demo(); string test = "This is {ONE}. This is {TWO}. This is {THREEPOINT}"; string res = LoggerState.MergeObjectToString(d, test); Debug.WriteLine(res); Assert.IsTrue(res.Equals("This is 1. This is a toucan. This is 3.14")); }
public void Log(string pLogMessage, LoggerState pErrorLevel) { // Propagate Log to GUI if (m_ViewHandle != null) { LogMessage LogMessageT1 = new LogMessage(); LogMessageT1.Message = pLogMessage; LogMessageT1.ErrorLevel = pErrorLevel; addImageAccordingToErrorLevel(pErrorLevel, LogMessageT1); this.m_AllLogsList.Add(LogMessageT1); applyFilter(); } switch (pErrorLevel) { case LoggerState.INFORMATION: m_Writer.Write("\r\nINFORMATION: "); m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString()); m_Writer.WriteLine(pLogMessage); m_Writer.WriteLine("-------------------------------"); break; case LoggerState.WARNING: m_Writer.Write("\r\nWARNING: "); m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString()); m_Writer.WriteLine(pLogMessage); m_Writer.WriteLine("-------------------------------"); break; case LoggerState.ERROR: m_Writer.Write("\r\nERROR: "); m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString()); m_Writer.WriteLine(pLogMessage); m_Writer.WriteLine("-------------------------------"); break; case LoggerState.CRITICAL: m_Writer.Write("\r\nCRITICAL: "); m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString()); m_Writer.WriteLine(pLogMessage); m_Writer.WriteLine("-------------------------------"); break; default: // TODO: do something smart here break; } m_Writer.Flush(); }
public void LogMove(bool isCheck, bool isCheckMate) { if (_state != LoggerState.PREPARED) { throw new DragonChessException("Logger is in an illegal state"); } _counter++; StringBuilder sb = new StringBuilder(); sb.Append(_counter).Append(". "); var movingPieceType = _movingPiece.GetType(); sb.Append(pieceCodes [movingPieceType]); if (_endPosition.z != 1 || movingPieceType != Type.GetType("Dragon")) { sb.Append(GetPositionNotation(_startPosition)); } if (_capturedPiece == null) { sb.Append("-"); } else { sb.Append("x"); sb.Append(pieceCodes [_capturedPiece.GetType()]); LogCapture(); } sb.Append(GetPositionNotation(_endPosition)); if (movingPieceType == Type.GetType("Warrior") && _endPosition.y == 7) { sb.Append("(H)"); } if (isCheckMate) { sb.Append(" mate"); } else if (isCheck) { sb.Append(" ch"); } Log.Add(sb.ToString()); Clear(); _state = LoggerState.IDLE; }
/// <summary> /// Log state changes /// </summary> private void SetState(LoggerState newState, string message, VoidVoid atomicOperation) { lock (this.stateLock) { Trace.WriteLine("SsmBasicLogger.SetState: invoked by " + message); Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "SsmBasicLogger.SetState: from {0} to {1}", this.state, newState)); this.state = newState; if (atomicOperation != null) { atomicOperation(); } } }
bool IXapLoggingProvider.Resume() { lock (this) { // Fail if logging hasn't been paused if (_loggerState != LoggerState.Paused) { return(false); } // Resume logging _loggerState = LoggerState.Running; return(true); } }
bool IXapLoggingProvider.Pause() { lock (this) { // Fail if logging hasn't been started if (_loggerState != LoggerState.Running) { return(false); } // Pause the logger _loggerState = LoggerState.Paused; return(true); } }
public static Exception WithState <TException>(this TException ex, LoggerState state) where TException : Exception { if (state != null) { var correlationId = ex.GetCorrelationId(); if (correlationId != Guid.Empty.ToString()) { state.CorrelationId = correlationId; } ex.AddState(state); } return(ex); }
public override (double l1, double l2, double l3) Get() { var avg = _measurements.CalculateAggregatedAverageUsage(); if (avg.nrOfDataPoints < MinimumDataPoints) { return(-1, -1, -1); } var chargeCurrent = Math.Round(LimitEco(avg.averageCharge, avg.averageUsage), 2); Logger?.LogInformation($"avg current {avg.averageUsage} and avg charging at {avg.averageCharge}; limitted chargecurrent = {chargeCurrent} ({avg.nrOfDataPoints} datapoints (buffer size {MaxBufferSeconds} seconds)"); if ((_state.Current == ChargingState.Charging && chargeCurrent < MinimumEcoModeExportStop) || (_state.Current != ChargingState.Charging && chargeCurrent < MinimumEcoModeExportStart)) { if (_state.Current == ChargingState.Charging) { _state.Pause(); LoggerState.Info($"Charging state pause {chargeCurrent}"); } return(0, 0, 0); } else { var t = AllowToCharge(); if (t.allow) { // charge as fast as possible and as close to the current available capicity as possible var avgShort = _measurements.CalculateAggregatedAverageUsage(DateTimeProvider.Now.AddSeconds(-10)); var chargeCurrentShort1 = Math.Round(LimitEco(avgShort.averageCharge, avgShort.averageUsage), 2); Logger?.LogInformation($"charging {chargeCurrent} -> {chargeCurrentShort1}"); if (t.changed) { LoggerState?.Info($"charging {chargeCurrent} -> {chargeCurrentShort1}"); } return((float)Math.Round(chargeCurrentShort1, 2), 0, 0); } else { Logger?.LogInformation($"charging {chargeCurrent} -> not yet allowed"); return(0, 0, 0); } } }
/* * In case of error during uprading return a modified nuget package * assume that that everything that should be removed is still there * in case of upgrade it might be harder because we can not be sure what happend before. * but the deployment action must handle this! */ public void Upgrade(string packageId, Version packageVersion, string packageDownloadUri) { var loggerstate = new LoggerState { { nameof(packageId), packageId }, { nameof(packageVersion), packageVersion }, { nameof(packageDownloadUri), packageDownloadUri }, }; logger.LogInformation("Upgrading package '{0}' to version '{1}'", packageId, packageVersion); using (logger.BeginScope(loggerstate)) { PerformanceLogger performanceLogger = new PerformanceLogger(logger); logger.LogInformation("Starting action on package xml list."); performanceLogger.Restart("Starting action on package xml list."); packageListRepository.StartActionOnPackage(packageId, packageVersion); performanceLogger.Stop(); logger.LogInformation("Installing new package."); performanceLogger.Restart("Installing new package."); NugetPackage upgradePackage = nugetPackageRepository.InstallPackage(packageId, packageVersion, packageDownloadUri); performanceLogger.Stop(); logger.LogInformation("Reading installed package."); performanceLogger.Restart("Reading installed package."); NugetPackage installedPackage = nugetPackageRepository.ReadInstalledPackage(packageId); logger.LogInformation("Installed Package: {0}", installedPackage?.PackageIdentifier); performanceLogger.Stop(); logger.LogInformation("Upgrading package."); performanceLogger.Restart("Upgrading package."); upgradePackage.Upgrade(logger, deploymentComponentFactory, installedPackage); performanceLogger.Stop(); logger.LogInformation("Archiving package."); performanceLogger.Restart("Archiving package."); nugetPackageRepository.ArchivePackage(packageId); performanceLogger.Stop(); logger.LogInformation("Ending action on package xml list."); performanceLogger.Restart("Ending action on package xml list."); packageListRepository.EndActionOnPackage(packageId, packageVersion); performanceLogger.Stop(); } }
public override (double l1, double l2, double l3) Get() { var avg = _measurements.CalculateAverageUsage(); if (avg.NrOfDataPoints < MinimumDataPoints) { return(-1, -1, -1); } LoggerState.Info($"avg current {avg.CurrentUsingL1}, {avg.CurrentUsingL2} , {avg.CurrentUsingL3}"); var retval1 = (float)Math.Round(LimitCurrent(avg.CurrentChargingL1, avg.CurrentUsingL1), 2); var retval2 = (float)Math.Round(LimitCurrent(avg.CurrentChargingL2, avg.CurrentUsingL2), 2); var retval3 = (float)Math.Round(LimitCurrent(avg.CurrentChargingL3, avg.CurrentUsingL3), 2); Logger?.LogInformation($"{(float)Math.Round(avg.CurrentUsingL1, 2)}, {(float)Math.Round(avg.CurrentUsingL2, 2)}, {(float)Math.Round(avg.CurrentUsingL3, 2)} => {retval1}, {retval2}, {retval3}"); return(retval1, retval2, retval3); }
public void PrepareMove(Vector3 start, Vector3 end, Board[] boards) { if (_state != LoggerState.IDLE) { throw new DragonChessException("Logger is in an illegal state"); } _startPosition = start; _movingPiece = boards [(int)start.z] [(int)start.x, (int)start.y].Piece.GetComponent <Piece> (); _endPosition = end; var capturedPieceObj = boards [(int)end.z] [(int)end.x, (int)end.y].Piece; if (capturedPieceObj != null) { _capturedPiece = capturedPieceObj.GetComponent <Piece> (); } _state = LoggerState.PREPARED; }
/// <summary>Ends the logger, dumping to a logfile.</summary> /// <param name="path">Full name and path of the logfile to dump to.</param> /// <param name="extraInfo">Any extra information to prepend to the logfile.</param> /// <param name="async">If the dump process should run in asynchronous mode.</param> /// <param name="completionCallback">An optional callback to execute upon completing the log dump.</param> public static void EndLogger(string path, string extraInfo = "", bool async = true, Action completionCallback = null) { if (currentLogger == null) { Debug.LogError("ERROR: No logger was running"); } else { CurrentState = LoggerState.Dumping; if (async) { //Ends logger, begins asynchronous dump, completing all main thread only tasks before entering async mode currentLogger.completionCallback = completionCallback; if (openLogFolder) { if (completionCallback == null) { currentLogger.completionCallback = () => ShowLogFolder(path); } else { currentLogger.completionCallback += () => ShowLogFolder(path); } } currentLogger.GetSystemSpecs(); Thread dumpThread = new Thread(new ThreadStart(() => currentLogger.DumpLog(path, extraInfo))); dumpThread.IsBackground = true; dumpThread.Start(); } else { //Dumps logfile and ends logger currentLogger.DumpLog(path, extraInfo); completionCallback(); if (openLogFolder) { ShowLogFolder(path); } Destroy(currentLogger.gameObject); currentLogger = null; } } }
bool IXapLoggingProvider.Stop() { lock (this) { // Fail if logging hasn't been started if (_loggerState != LoggerState.Running) { return(false); } // Stop logging try { _logFile.Close(); _logFile = null; } catch { return(false); } _loggerState = LoggerState.Stopped; return(true); } }
public static void AddState <TException>(this TException ex, LoggerState state) where TException : Exception { if (ex != null) { var mergeState = state; if (ex.Data.Contains(ExceptionStateKey)) { var prevState = ex.Data[ExceptionStateKey] as LoggerState; if (prevState != null) { mergeState = prevState.MergedWith(state); } } if (mergeState != null) { ex.Data[ExceptionStateKey] = mergeState; } } }
/// <summary> /// A operação Shutdown bloqueia a thread invocante até que todos os relatórios submetidos até ao momento sejam efectivamente /// escritos; relatórios submetidos posteriormente são rejeitados (i.e. chamadas a LogMessage produzem excepção). /// </summary> public void Shutdown() { lock (this) { _state = LoggerState.Shutdown; if (_msgQueue.Count == 0) { _myTw.Close(); return; } do { // try // { Monitor.Wait(this); // } // catch (ThreadInterruptedException) // { // foreach (var msg in _msgQueue) // { // _msgQueue.Remove(msg); // } // throw; // } if (_msgQueue.Count == 0) { _myTw.Close(); return; } } while (true); } }
private static void LogPrefix(LoggerState state) { if (state == LoggerState.Success) { Console.ForegroundColor = ConsoleColor.Green; Console.Write("[Success] "); } else if (state == LoggerState.Failure) { Console.ForegroundColor = ConsoleColor.Red; Console.Write("[Failure] "); } else if (state == LoggerState.Warning) { Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("[Warning] "); } else if (state == LoggerState.Informational) { Console.Write("[Information] "); } Console.ForegroundColor = ConsoleColor.White; }
///<summary>Sets logger state, and by default writes to Console.Out(stdout).</summary> public Logger(LoggerState state) { CurrentState = state; WriteTo = Console.Out; }
public AlgorithmLibEventArgs(LoggerState _state, string _mesage) { message = _mesage; state = _state; }
///<summary> /// Sets logger state. ///</summary> public static void UseLogger(LoggerState state) { logger.CurrentState = state; }
/// <summary> /// Log state changes /// </summary> private void SetState(LoggerState newState, string message) { this.SetState(newState, message, null); }
protected virtual bool StartLog(IXapLoggingContext loggingContext) { if (string.IsNullOrWhiteSpace(loggingContext.LogFileLocation)) { _logFilename = XapEnvironment.Instance.MapFolderPath(XapConfig.Instance.GetValue <string>($"{XapEnvironment.Instance.EnvironmentName}.logging", "logFile")); } else { _logFilename = loggingContext.LogFileLocation; } _bAppend = loggingContext.AppendToLog; _levels = loggingContext.LoggingLevel; lock (this) { // Fail if logging has already been started if (_loggerState != LoggerState.Stopped) { return(false); } // Fail if the log file isn't specified if (String.IsNullOrEmpty(_logFilename)) { return(false); } // Delete log file if it exists if (!_bAppend) { try { File.Delete(_logFilename); } catch (Exception) { return(false); } } // Open file for writing - return on error if (!File.Exists(_logFilename)) { try { _logFile = File.CreateText(_logFilename); } catch (Exception) { _logFile = null; return(false); } } else { try { _logFile = File.AppendText(_logFilename); } catch { _logFile = null; return(false); } } _logFile.AutoFlush = true; // Return successfully _loggerState = LoggerState.Running; return(true); } }
/// <summary> /// A classe inclui ainda as operações Start e Shutdown que promovem o início e a terminação do /// registo de relatórios, respectivamente. /// </summary> public void Start() { _state = LoggerState.Working; _loggerThread = new Thread((msg) => { lock (this) { LinkedListNode<string> myNode = new LinkedListNode<string>(((string) msg)); _msgQueue.AddLast(myNode); do { try { Monitor.Wait(this); } catch (ThreadInterruptedException) { _msgQueue.Remove(myNode); throw; } if (_msgQueue.First == myNode) { // TODO : Comparar a thread actual com a loggerthread (priority), NOT FINISHED! (Não faz sentido!!) if (Thread.CurrentThread.Priority < _loggerThread.Priority) { _myTw.Write(msg); Monitor.PulseAll(this); } } } while (true); } }); _loggerThread.Priority = ThreadPriority.BelowNormal; }
public void Shutdown() { lock (this) { if (_state == LoggerState.SHUTDOWN) return; _state = LoggerState.SHUTDOWN; do { // Esperar pelo fim de todas as escritas if (messagesToWrite.Count == 0) { _writer.Close(); return; } try { Monitor.Wait(this); } catch (ThreadInterruptedException iex) { _writer.Close(); throw; } } while (true); } }
public Ex5Logger(TextWriter tw) { _msgQueue = new LinkedList<string>(); _myTw = tw; _state = LoggerState.NotStarted; }
public Ex5Logger(TextWriter writer) { messagesToWrite = new LinkedList<MsgSenderThread>(); _state = LoggerState.NOT_ACTIVE; _writer = writer; }
public void Start() { _loggerThread = new Thread( () => { lock (this) { if (_state == LoggerState.NOT_ACTIVE) _state = LoggerState.ACTIVE; do { if (messagesToWrite.Count>0) { foreach(MsgSenderThread msgNode in messagesToWrite){ if(!msgNode.Processed){ _writer.WriteLine(msgNode.Msg); msgNode.Processed = true; Monitor.PulseAll(this); // Notificar threads, para elas verem se a sua msg ja foi escrita no ficheiro } } } try { Monitor.Wait(this); } catch (ThreadInterruptedException iex) { foreach (MsgSenderThread msg in messagesToWrite) messagesToWrite.Remove(msg); Monitor.PulseAll(this); } } while (true); } }); _loggerThread.Priority = ThreadPriority.Lowest; _state = LoggerState.ACTIVE; _loggerThread.Start(); }