/// <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);
}
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);
}
/// <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);
}
