/// <summary>機能の実行を記録する。</summary> /// <param name="target">対象の機能(Screen/Dialog)</param> /// <param name="funcKeyNo">Fキー番号</param> /// <param name="action">機能の本処理</param> internal static void FunctionCalled(this ILoggable target, int funcKeyNo, Action action) { if (action == null) { return; } bool logging = (target.ApplicationControl?.UseOperationLogging ?? 0) == 1; ILogin login = target.Login; string viewCaption = target.Caption; MeasurementHelper.ProcessStart(); if (logging) { var attribute = action.Method .GetCustomAttributes(false) .OfType <OperationLogAttribute>() .FirstOrDefault(); if (attribute != null) { LogAsync(login, null, viewCaption, $"F{funcKeyNo}:{attribute.FunctionName}"); } } action(); if (!string.IsNullOrEmpty(viewCaption) && funcKeyNo != 10) { MeasurementHelper.ProcessEnd($"{viewCaption} F{funcKeyNo}"); } }
public static void Fatal(this ILoggable logger, object message, Exception exception) { if (message != null) { Log(logger, new LogMessage(LogLevel.Fatal, message, exception)); } }
public static void Log(this ILoggable logger, LogLevel level, string format, params object[] args) { if (format != null) { Log(logger, new LogMessage(level, string.Format(format, args))); } }
public static void Error(this ILoggable logger, object message) { if (message != null) { Log(logger, new LogMessage(LogLevel.Error, message)); } }
public static void Debug(this ILoggable logger, object message) { if (message != null) { Log(logger, new LogMessage(LogLevel.Debug, message)); } }
public static void Trace(this ILoggable logger, object message) { if (message != null) { Log(logger, new LogMessage(LogLevel.Trace, message)); } }
public ChatServer(ILoggable logger) { tcpListener = new TcpListener(localIPParsed, portNumber); clientDatabase = new Dictionary <string, TcpClient>(); messageQueue = new Queue <string>(); this.logger = logger; }
/// <summary> /// Removes all the excess spaces around the specified separator /// </summary> /// <param name="line"></param> /// <param name="separator"></param> /// <param name="logobj"></param> /// <returns></returns> public static string RemoveExcessSpaces(string line, string separator, ILoggable logobj) { string ret = line.Split(' ', StringSplitOptions.RemoveEmptyEntries).Unpack(separator); Logger.Log(logobj, DebugLevel.LOGS, Verbosity.LEVEL7, "Removing Excess Spaces: {0} => {1}", line, ret); return(ret); }
public PeerListService(IConfiguration configuration, ILoggable logger, IPeerList peers) { Configuration = configuration; Logger = logger; Peers = peers; if (MasterKey.Address != EndPoint.Address) { throw new ArgumentException("MasterKey enode mismatch"); } // TCP server start Server = new TcpServer() { OnStart = OnTcpStart, OnStop = OnTcpStop, OnAccept = OnTcpAccept, OnClose = OnTcpClose, OnMessage = OnTcpMessage }; commandLineInterpreter = new CommandLineInterpreter() { OnCommand = OnConsoleCommand }; }
public void Attach(ILoggable logger) { lock (_loggers) { _loggers.Add(logger); } }
public ElasticGridNetworkTests(ILoggable logger, IElasticNode node, IPeerList peers, PrivateKey nodeKey) { Logger = logger; Node = node; Peers = peers; NodeKey = nodeKey; }
public ClientManager(Core core, ILoggable Log = null) { ClientManager.core = core; ClientManager.Log = Log ?? new NullLogger(); _ = new ClientServer(Config.TcpPortApi); }
public void Dettach(ILoggable logger) { lock (_loggers) { _loggers.Remove(logger); } }
public void Log(ILoggable message) { using (System.IO.StreamWriter writer = new System.IO.StreamWriter(this.filePath)) { writer.WriteLine(message.GetStringRepresentation()); } }
public EventBatch(int cid, DateTimeOffset preferredTime, ILoggable loggable) { _preferredTime = preferredTime; _events = new List <Entities.Event>(); _cid = cid; _loggable = loggable; }
public static ILogger GetLogger(ILoggable instance) { ILogger result; if (instance == null) { return(null); } var depth = LoggableRecursionGuard.Value; try { LoggableRecursionGuard.Value++; if (depth == 0) { result = instance.Logger; if (result != null) { return(result); } } var name = (instance as INamed)?.Name ?? Convert.ToString(instance); result = new DefaultLogger(name, GetDefaultAppenders(), null); } finally { LoggableRecursionGuard.Value = depth; } return(result); }
public void AttachLogger(ILoggable Logger) { mLoggesList.Add(Logger); Logger.LogStartedEvent += new EventHandler(Logger_LogStartedEvent); Logger.ErrorEvent += new EventHandler<PKStudio.Helpers.ErrorEventArgs>(Logger_ErrorEvent); Logger.WarningEvent += new EventHandler<WarningEventArgs>(Logger_WarningEvent); Logger.MessageEvent += new EventHandler<MessageEventArgs>(Logger_MessageEvent); }
public void Add(ILoggable log) { if (Logs.Count == Limit) { Logs.RemoveAt(0); } Logs.Add(log); }
/// <summary> /// Monitors the specified source. /// </summary> /// <param name="source">The source.</param> /// <param name="names">The names.</param> public void Monitor(ILoggable source, IEnumerable<string> names) { source.DataAvailable += source_DataAvailable; _names = names; foreach (string name in names) DataSet.Add(new Series(name){Maximum = 1, Minimum = -1}); }
private Peer(Core Core, Operations Operations, TcpClient Client, ILoggable Log = null) : base(Operations, Client) { this.Log = Log ?? new NullLogger(); this.Core = Core; OpenenConn += Peer_OpenenConn; ClosedConn += Peer_ClosedConn; }
public void AttachLogger(ILoggable Logger) { mLoggesList.Add(Logger); Logger.LogStartedEvent += new EventHandler(Logger_LogStartedEvent); Logger.LogFinishedEvent += new EventHandler <LogFinishedEventArgs>(Logger_LogFinishedEvent); Logger.ErrorEvent += new EventHandler <PKStudio.Helpers.ErrorEventArgs>(Logger_ErrorEvent); Logger.WarningEvent += new EventHandler <WarningEventArgs>(Logger_WarningEvent); }
public void detachLogger(ILoggable Logger) { mLoggesList.Remove(Logger); Logger.LogStartedEvent -= new EventHandler(Logger_LogStartedEvent); Logger.ErrorEvent -= new EventHandler <PKStudio.Helpers.ErrorEventArgs>(Logger_ErrorEvent); Logger.WarningEvent -= new EventHandler <WarningEventArgs>(Logger_WarningEvent); Logger.MessageEvent -= new EventHandler <MessageEventArgs>(Logger_MessageEvent); }
public LogEntry(TimeSpan loggedTotalWorldTime, ILoggable loggable, LogEntryType entryType, TimeSpan logEntryLifetime) { _loggedTotalWorldTime = loggedTotalWorldTime; _entryType = entryType; _title = loggable.Title; _details = loggable.Details.ToArray(); _fadeHelper = new TimedLerpHelper(loggedTotalWorldTime + logEntryLifetime - Constants.LogRenderer.FadeDuration, Constants.LogRenderer.FadeDuration, 1f, 0f); }
public ChatRoom(ILoggable logger) { connectedClients = new Dictionary(); server = new TcpListener(IPAddress.Any, 8888); messageQueue = new Queue <string>(); serverQueue = new Queue <string>(); fileLogger = logger; }
public NodeClient(ILoggable logger) { Logger = logger; _tcp_client = new TcpClient(logger) { }; }
/// <summary> /// Gets the logger source info. /// </summary> /// <param name="nodeId">The node id.</param> /// <param name="loggableMetadata">The loggable metadata.</param> /// <param name="loggerNameRoot">The logger name root.</param> /// <returns></returns> private static string GetLoggerSourceInfo(string nodeId, ILoggable loggableMetadata, LoggerNameRoot loggerNameRoot) { return(GetLoggerSourceInfo(nodeId, loggerNameRoot, loggableMetadata.Classname, loggableMetadata.SourceAssembly, loggableMetadata.Label)); }
internal void Run(string environment) { ILoggable log = LoggerFactory.GetLogger(environment); _actions.Add("ClientX"); log.Log("1"); log.Log("2"); }
public void detachLogger(ILoggable Logger) { mLoggesList.Remove(Logger); Logger.LogStartedEvent -= new EventHandler(Logger_LogStartedEvent); Logger.LogFinishedEvent -= new EventHandler<LogFinishedEventArgs>(Logger_LogFinishedEvent); Logger.ErrorEvent -= new EventHandler<PKStudio.Helpers.ErrorEventArgs>(Logger_ErrorEvent); Logger.WarningEvent -= new EventHandler<WarningEventArgs>(Logger_WarningEvent); }
/// <summary> /// Add logs /// </summary> /// <param name="loggable"></param> public void AddLog(ILoggable loggable) { if (_logs.Count > _maxLogToFlush) { Flush(); } _logs.Add(loggable); }
private BLog(bool global) { _loggers = new List <ILoggable>(); if (global) { Global = this; } }
public void SetLogger(ILoggable logger) { if (logger == null) { _log.Warn("Can't set logger. Logger instance equals null."); throw new ArgumentNullException(); } _log = new LogAdapter(logger); }
private ILoggable GetLogger() { if (this.logger == null && DbHelper.HasConnection($"{instance}_log")) { this.logger = new Logger($"{instance}_log"); } return(this.logger); }
protected override void WriteLog(ILoggable entry) { if (!ShouldLog(entry.Severity)) { return; } Console.Out.WriteLineAsync(entry.ToString()); base.WriteLog(entry); }
public Server(ILoggable logger) { this.logger = logger; server = new TcpListener(IPAddress.Parse(IPFinder.GetLocalIPAddress()), 9999); Users = new Dictionary <string, Client>(); queue = new Queue <string[]>(); thiskey = new object(); server.Start(); }
/// <summary> /// Creates the logger for the given metadata and node id /// </summary> /// <param name="loggerNameRoot">The logger name root.</param> /// <param name="nodeId">The node id.</param> /// <param name="loggableMetadata">The metadata.</param> /// <returns></returns> internal static ComponentLogger CreateLogger(LoggerNameRoot loggerNameRoot, string nodeId, ILoggable loggableMetadata) { string loggerName = GetLoggerSourceInfo(nodeId, loggableMetadata, loggerNameRoot); CreateLoggingRules(loggerName, loggableMetadata.LogLevels); if (string.IsNullOrEmpty(loggerName)) loggerName = Guid.NewGuid().ToString(); return new ComponentLoggerImplementation(loggerName); }
/// <summary> /// Logs the transaction data to the file and remembers the start position. /// </summary> /// <param name="itemToLog"></param> public void LogStartTransaction(ILoggable itemToLog) { // get the start position _currentTransactionDataStartPosition = (ulong) _persistenceManager.GetFileLength(GetTransactionLogFile()); // now write the transaction data using (var stream = _persistenceManager.GetOutputStream(GetTransactionLogFile(), FileMode.Append)) { itemToLog.LogTransactionDataToStream(stream); } }
/// <summary> /// Called when a job completes successfully so that the header can be written. /// </summary> /// <param name="itemToLog"></param> public void LogEndSuccessfulTransaction(ILoggable itemToLog) { var endPosition = (ulong) _persistenceManager.GetFileLength(GetTransactionLogFile()); var contentLength = endPosition - _currentTransactionDataStartPosition; using (var stream = _persistenceManager.GetOutputStream(GetTransactionLogHeaderFile(), FileMode.Append)) { var transactionHeader = new TransactionInfo(itemToLog.TransactionId, TransactionStatus.CompletedOk, itemToLog.TransactionType, _currentTransactionDataStartPosition, contentLength, DateTime.UtcNow); using(var binaryWriter = new BinaryWriter(stream)) { transactionHeader.Save(binaryWriter); } } }
public LogAdapter(ILoggable logger) { _logger = logger; }
public void LogStartTransaction(ILoggable itemToLog) { return; }
public void LogEndSuccessfulTransaction(ILoggable itemToLog) { return; }
internal static Logger GetLogger(ILoggable loggable) { return new Logger(loggable.GetType()); }
public void LogEndFailedTransaction(ILoggable itemToLog) { return; }
/// <summary> /// Gets the logger source info. /// </summary> /// <param name="nodeId">The node id.</param> /// <param name="loggableMetadata">The loggable metadata.</param> /// <param name="loggerNameRoot">The logger name root.</param> /// <returns></returns> private static string GetLoggerSourceInfo(string nodeId, ILoggable loggableMetadata, LoggerNameRoot loggerNameRoot) { return GetLoggerSourceInfo(nodeId, loggerNameRoot, loggableMetadata.Classname, loggableMetadata.SourceAssembly, loggableMetadata.Label); }
public virtual void ConfigureLoggable(ILoggable loggable) { //attach the default implementation of ILogger //to the loggable object loggable.Logger = GetObject<ILogger>(); }
public static Logger GetLogger(ILoggable loggable, LoggingConfiguration config) { return GetLogger(loggable.GetType().Name, config); }