/// <summary>
/// Adds a log writer and binds to a specific log message type
/// </summary>
/// <param name="logMessageType">Type of log message</param>
/// <param name="logWriter">Log writer to add</param>
public void AddLogWriter(NiawaLogType logMessageType, ILogWriter logWriter)
{
//Ensure that more than one instance of a ILogWriter implementation (of a specific type) is not added.
if(_logWriters.ContainsKey(logWriter.GetType().ToString()))
if (_logWriters[logWriter.GetType().ToString()].LogWriterID != logWriter.LogWriterID)
throw new Exception("Cannot add two instances of the same ILogWriter type [" + logWriter.GetType().ToString() + "]. Add a different type of ILogWriter, or add an existing instance of this ILogWriter type.");
//Check for duplicate entry attempts into the LogMessageTypeLogWriters collection
if (_logMessageTypeLogWriters.ContainsKey(logMessageType))
if (_logMessageTypeLogWriters[logMessageType].Contains(logWriter))
throw new Exception("Cannot add the same ILogWriter [" + logWriter.GetType().ToString() + "] for LogMessageType [" + Enum.GetName(logMessageType.GetType(), logMessageType) + "] more than once.");
//add log writer to list
if (!(_logWriters.ContainsKey(logWriter.GetType().ToString())))
_logWriters.Add(logWriter.GetType().ToString(), logWriter);
//add log writer to map
List<ILogWriter> mapLogWriters = null;
//check if log message type already in map
if (_logMessageTypeLogWriters.ContainsKey(logMessageType))
mapLogWriters = _logMessageTypeLogWriters[logMessageType];
else
{
//create new entry of log writers for log message type and add to map
mapLogWriters = new List<ILogWriter>();
_logMessageTypeLogWriters.Add(logMessageType, mapLogWriters);
}
//add log writer to list of log writers mapped to log message type
mapLogWriters.Add(logWriter);
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpClientContext"/> class.
/// </summary>
/// <param name="secured">true if the connection is secured (SSL/TLS)</param>
/// <param name="remoteEndPoint">client that connected.</param>
/// <param name="stream">Stream used for communication</param>
/// <param name="parserFactory">Used to create a <see cref="IHttpRequestParser"/>.</param>
/// <param name="bufferSize">Size of buffer to use when reading data. Must be at least 4096 bytes.</param>
/// <exception cref="SocketException">If <see cref="Socket.BeginReceive(byte[],int,int,SocketFlags,AsyncCallback,object)"/> fails</exception>
/// <exception cref="ArgumentException">Stream must be writable and readable.</exception>
public HttpClientContext(bool secured, IPEndPoint remoteEndPoint,
Stream stream, IRequestParserFactory parserFactory, int bufferSize, Socket sock, ILogWriter log)
{
Check.Require(remoteEndPoint, "remoteEndPoint");
Check.NotEmpty(remoteEndPoint.Address.ToString(), "remoteEndPoint.Address");
Check.Require(stream, "stream");
Check.Require(parserFactory, "parser");
Check.Min(4096, bufferSize, "bufferSize");
Check.Require(sock, "socket");
if (!stream.CanWrite || !stream.CanRead)
throw new ArgumentException("Stream must be writable and readable.");
_bufferSize = bufferSize;
RemoteAddress = remoteEndPoint.Address.ToString();
RemotePort = remoteEndPoint.Port.ToString();
_log = log;
_parser = parserFactory.CreateParser(_log);
_parser.RequestCompleted += OnRequestCompleted;
_parser.RequestLineReceived += OnRequestLine;
_parser.HeaderReceived += OnHeaderReceived;
_parser.BodyBytesReceived += OnBodyBytesReceived;
_currentRequest = new HttpRequest();
IsSecured = secured;
if (stream == null)
throw new NullReferenceException ("Null Stream in HttpClientContext");
_stream = stream;
_buffer = new byte[bufferSize];
}
public DatabaseFactory(IConnectionString connectionString, ILogWriter logWriter)
{
Checks.Argument.IsNotNull(connectionString, "connectionString");
_connectionString = connectionString.Value;
_logWriter = logWriter;
}
public MSBuildResult[] RunTarget (string target, ProjectConfigurationInfo[] configurations, ILogWriter logWriter,
MSBuildVerbosity verbosity)
{
MSBuildResult[] result = null;
BuildEngine.RunSTA (delegate
{
try {
var project = SetupProject (configurations);
currentLogWriter = logWriter;
LocalLogger logger = new LocalLogger (Path.GetDirectoryName (file));
engine.UnregisterAllLoggers ();
engine.RegisterLogger (logger);
engine.RegisterLogger (consoleLogger);
consoleLogger.Verbosity = GetVerbosity (verbosity);
project.Build (target);
result = logger.BuildResult.ToArray ();
// } catch (InvalidProjectFileException ex) {
// result = new MSBuildResult[] { new MSBuildResult (false, ex.ProjectFile ?? file, ex.LineNumber, ex.ColumnNumber, ex.ErrorCode, ex.Message) };
} finally {
currentLogWriter = null;
}
});
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpClientContext"/> class.
/// </summary>
/// <param name="secured">true if the connection is secured (SSL/TLS)</param>
/// <param name="remoteEndPoint">client that connected.</param>
/// <param name="stream">Stream used for communication</param>
/// <param name="clientCertificate">Client security certificate</param>
/// <param name="parserFactory">Used to create a <see cref="IHttpRequestParser"/>.</param>
/// <param name="bufferSize">Size of buffer to use when reading data. Must be at least 4096 bytes.</param>
/// <param name="socket">Client socket</param>
/// <exception cref="SocketException">If <see cref="Socket.BeginReceive(byte[],int,int,SocketFlags,AsyncCallback,object)"/> fails</exception>
/// <exception cref="ArgumentException">Stream must be writable and readable.</exception>
public HttpClientContext(bool secured, IPEndPoint remoteEndPoint, Stream stream,
ClientCertificate clientCertificate, IRequestParserFactory parserFactory, int bufferSize, Socket socket)
{
Check.Require(remoteEndPoint, "remoteEndPoint");
Check.NotEmpty(remoteEndPoint.Address.ToString(), "remoteEndPoint.Address");
Check.Require(stream, "stream");
Check.Require(parserFactory, "parser");
Check.Min(4096, bufferSize, "bufferSize");
Check.Require(socket, "socket");
if (!stream.CanWrite || !stream.CanRead)
throw new ArgumentException("Stream must be writable and readable.");
_bufferSize = bufferSize;
RemoteAddress = remoteEndPoint.Address.ToString();
RemotePort = remoteEndPoint.Port.ToString();
_log = NullLogWriter.Instance;
_parser = parserFactory.CreateParser(_log);
_parser.RequestCompleted += OnRequestCompleted;
_parser.RequestLineReceived += OnRequestLine;
_parser.HeaderReceived += OnHeaderReceived;
_parser.BodyBytesReceived += OnBodyBytesReceived;
_localEndPoint = (IPEndPoint)socket.LocalEndPoint;
HttpRequest request = new HttpRequest();
request._remoteEndPoint = remoteEndPoint;
request.Secure = secured;
_currentRequest = request;
IsSecured = secured;
_stream = stream;
_clientCertificate = clientCertificate;
_buffer = new byte[bufferSize];
}
public AutomaticMigration(IAccessDb db, IManageMigrations migrations, ILogWriter logger)
{
_db = db;
_migrations = migrations;
_runner=new MigrationTaskRunner(db,logger);
UpdateSelf();
}
public DefaultRackServer(int port,IPAddress ipAddress,ILogWriter logWriter)
{
_server = new HttpServer.HttpServer(logWriter);
_ipAddress = ipAddress;
_port = port;
_logWriter = logWriter;
}
public void Attach(ILogWriter newLogWriter)
{
if (newLogWriter == null)
throw new ArgumentNullException("newLogWriter");
if (newLogWriter == this.WrappedLogWriter)
return;
ILogWriter prevLogWriter = this.WrappedLogWriter;
Exception detachException = null;
if (this.WrappedLogWriter != null)
{
try
{
prevLogWriter.Detach();
}
catch (Exception ex)
{
detachException = ex;
}
this.WrappedLogWriter.ServerWriteLine(
string.Format("Log writer \"{0}\" is being detached.", this.LogWriterName), TraceLevel.Verbose);
}
this.WrappedLogWriter = newLogWriter;
this.WrappedLogWriter.ServerWriteLine(
string.Format("Log writer \"{0}\" has been attached.", this.LogWriterName), TraceLevel.Verbose);
if (detachException != null)
this.ServerWriteLine(
string.Format("Log writer \"{0}\" had thrown an unexpected exception:\n{1}", prevLogWriter.Name, detachException),
TraceLevel.Error);
}
public MSBuildResult[] RunTarget (string target, ProjectConfigurationInfo[] configurations, ILogWriter logWriter,
MSBuildVerbosity verbosity)
{
MSBuildResult[] result = null;
BuildEngine.RunSTA (delegate
{
try {
var project = SetupProject (configurations);
currentLogWriter = logWriter;
var logger = new LocalLogger (file);
buildEngine.Engine.UnregisterAllLoggers ();
buildEngine.Engine.RegisterLogger (logger);
buildEngine.Engine.RegisterLogger (consoleLogger);
consoleLogger.Verbosity = GetVerbosity (verbosity);
// We are using this BuildProject overload and the BuildSettings.None argument as a workaround to
// an xbuild bug which causes references to not be resolved after the project has been built once.
buildEngine.Engine.BuildProject (project, new [] { target }, new Hashtable (), BuildSettings.None);
result = logger.BuildResult.ToArray ();
} catch (InvalidProjectFileException ex) {
var r = new MSBuildResult (
file, false, ex.ErrorSubcategory, ex.ErrorCode, ex.ProjectFile,
ex.LineNumber, ex.ColumnNumber, ex.EndLineNumber, ex.EndColumnNumber,
ex.BaseMessage, ex.HelpKeyword);
logWriter.WriteLine (r.ToString ());
result = new [] { r };
} finally {
currentLogWriter = null;
}
});
return result;
}
public MSBuildResult[] RunTarget (string target, ProjectConfigurationInfo[] configurations, ILogWriter logWriter,
MSBuildVerbosity verbosity)
{
MSBuildResult[] result = null;
BuildEngine.RunSTA (delegate
{
try {
var project = SetupProject (configurations);
currentLogWriter = logWriter;
var logger = new LocalLogger (file);
engine.UnregisterAllLoggers ();
engine.RegisterLogger (logger);
engine.RegisterLogger (consoleLogger);
consoleLogger.Verbosity = GetVerbosity (verbosity);
project.Build (target);
result = logger.BuildResult.ToArray ();
} catch (Microsoft.Build.Exceptions.InvalidProjectFileException ex) {
var r = new MSBuildResult (
file, false, ex.ErrorSubcategory, ex.ErrorCode, ex.ProjectFile,
ex.LineNumber, ex.ColumnNumber, ex.EndLineNumber, ex.EndColumnNumber,
ex.BaseMessage, ex.HelpKeyword);
logWriter.WriteLine (r.ToString ());
result = new [] { r };
} finally {
currentLogWriter = null;
}
});
return result;
}
public void RegisterLogWriter(ILogWriter logWriter)
{
lock (SyncroObject)
{
LogWriters.Add(logWriter);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpClientContextImp"/> class.
/// </summary>
/// <param name="secured">true if the connection is secured (SSL/TLS)</param>
/// <param name="remoteEndPoint">client that connected.</param>
/// <param name="requestHandler">delegate handling incoming requests.</param>
/// <param name="disconnectHandler">delegate being called when a client disconnectes</param>
/// <param name="stream">Stream used for communication</param>
/// <exception cref="SocketException">If beginreceive fails</exception>
/// <param name="writer">delegate used to write log entries</param>
/// <see cref="RequestReceivedHandler"/>
/// <see cref="ClientDisconnectedHandler"/>
public HttpClientContextImp(bool secured, IPEndPoint remoteEndPoint,
RequestReceivedHandler requestHandler,
ClientDisconnectedHandler disconnectHandler,
Stream stream, ILogWriter writer)
{
Check.Require(requestHandler, "requestHandler");
Check.Require(remoteEndPoint, "remoteEndPoint");
Check.Require(remoteEndPoint.Address, "remoteEndPoint.Address");
Check.Require(stream, "stream");
if (!stream.CanWrite || !stream.CanRead)
throw new ArgumentException("Stream must be writeable and readable.");
_remoteEndPoint = remoteEndPoint;
_log = writer ?? NullLogWriter.Instance;
_parser = new HttpRequestParser(OnRequestCompleted, null);
_secured = secured;
_requestHandler = requestHandler;
_disconnectHandler = disconnectHandler;
_stream = stream;
try
{
_stream.BeginRead(_buffer, 0, BUFFER_SIZE, OnReceive, null);
}
catch (IOException err)
{
_log.Write(this, LogPrio.Debug, err.ToString());
_stream = null;
_disconnectHandler(this, SocketError.ConnectionAborted);
}
}
/// <summary>
/// Creates an asynchronous logger using the provider log writer.
/// </summary>
/// <param name="writer">The log writer that will log the log entries.</param>
public AsyncLogger(ILogWriter writer)
{
if (writer == null)
throw new ArgumentNullException(nameof(writer));
this.writer = writer;
}
public void UnregisterLogWriter(ILogWriter logWriter)
{
lock (SyncroObject)
{
LogWriters.Remove(logWriter);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpContextFactory"/> class.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="bufferSize">Amount of bytes to read from the incoming socket stream.</param>
/// <param name="factory">Used to create a request parser.</param>
public HttpContextFactory(ILogWriter writer, int bufferSize, IRequestParserFactory factory)
{
_logWriter = writer;
_bufferSize = bufferSize;
_factory = factory;
_contextTimeoutManager = new ContextTimeoutManager(ContextTimeoutManager.MonitorType.Thread);
}
public MSBuildResult Run (
ProjectConfigurationInfo[] configurations, ILogWriter logWriter, MSBuildVerbosity verbosity,
string[] runTargets, string[] evaluateItems, string[] evaluateProperties)
{
MSBuildResult result = null;
BuildEngine.RunSTA (delegate {
try {
var project = SetupProject (configurations);
currentLogWriter = logWriter;
buildEngine.Engine.UnregisterAllLoggers ();
var logger = new LocalLogger (file);
buildEngine.Engine.RegisterLogger (logger);
if (logWriter != null) {
buildEngine.Engine.RegisterLogger (consoleLogger);
consoleLogger.Verbosity = GetVerbosity (verbosity);
}
if (runTargets != null && runTargets.Length > 0) {
// We are using this BuildProject overload and the BuildSettings.None argument as a workaround to
// an xbuild bug which causes references to not be resolved after the project has been built once.
buildEngine.Engine.BuildProject (project, runTargets, new Hashtable (), BuildSettings.None);
}
result = new MSBuildResult (logger.BuildResult.ToArray ());
if (evaluateProperties != null) {
foreach (var name in evaluateProperties)
result.Properties [name] = project.GetEvaluatedProperty (name);
}
if (evaluateItems != null) {
foreach (var name in evaluateItems) {
BuildItemGroup grp = project.GetEvaluatedItemsByName (name);
var list = new List<MSBuildEvaluatedItem> ();
foreach (BuildItem item in grp) {
var evItem = new MSBuildEvaluatedItem (name, UnescapeString (item.FinalItemSpec));
foreach (DictionaryEntry de in (IDictionary) evaluatedMetadataField.GetValue (item)) {
evItem.Metadata [(string)de.Key] = UnescapeString ((string)de.Value);
}
list.Add (evItem);
}
result.Items[name] = list;
}
}
} catch (InvalidProjectFileException ex) {
var r = new MSBuildTargetResult (
file, false, ex.ErrorSubcategory, ex.ErrorCode, ex.ProjectFile,
ex.LineNumber, ex.ColumnNumber, ex.EndLineNumber, ex.EndColumnNumber,
ex.BaseMessage, ex.HelpKeyword);
logWriter.WriteLine (r.ToString ());
result = new MSBuildResult (new [] { r });
} finally {
currentLogWriter = null;
}
});
return result;
}
public Log(ILogWriter traceWriter, ILogWriter eventLogWriter, string system, bool logSuccesAudit, bool logFailureAudit)
{
this.traceWriter = traceWriter;
this.eventLogWriter = eventLogWriter;
systemLogging = system;
this.logSuccesAudit = logSuccesAudit;
this.logFailureAudit = logFailureAudit;
}
public static void AddLogWriter(ILogWriter logWriter, ILogFormatter logFormatter)
{
logWriters.Add(new LogWriterInfo()
{
logWriter = logWriter,
logFormatter = logFormatter
});
}
/// <summary>
/// Create a new request parser
/// </summary>
/// <param name="requestCompleted">delegate called when a complete request have been generated</param>
/// <param name="logWriter">delegate receiving log entries.</param>
public HttpRequestParser(RequestCompletedHandler requestCompleted, ILogWriter logWriter)
{
if (requestCompleted == null)
throw new ArgumentNullException("requestCompleted");
_log = logWriter ?? NullLogWriter.Instance;
RequestCompleted = requestCompleted;
}
public MSBuildResult[] RunTarget (string target, ProjectConfigurationInfo[] configurations, ILogWriter logWriter,
MSBuildVerbosity verbosity)
{
if (target == null)
throw new ArgumentNullException ("target");
return builder.RunTarget (target, configurations, logWriter, verbosity);
}
public Logger(ILogWriter logWriter)
{
if (logWriter == null)
{
throw new ArgumentNullException("logWriter");
}
this.logWriter = logWriter;
}
public static void UnregisterLogWriter(ILogWriter writer)
{
lock (_writersLock)
{
int index = Writers.IndexOf(writer);
if (index != -1)
Writers.RemoveAt(index);
}
}
/// <summary>
/// Dumps the element ids.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="logWriter">The log writer.</param>
public static void DumpElements(Document document, ILogWriter logWriter)
{
logWriter.LogAction("Dump:");
IHTMLElementCollection elements = elementCollection(document);
foreach (IHTMLElement e in elements)
{
logWriter.LogAction("id = " + e.id);
}
}
/// <summary>
/// Prepares the logging infrastructure
/// </summary>
void InitLogger (ILogWriter logWriter)
{
currentLogWriter = logWriter;
if (currentLogWriter != null) {
log.Clear ();
flushingLog = false;
flushTimer = new Timer (o => FlushLog ());
}
}
/// <inheritdoc />
public void AddWriter(ILogWriter writer)
{
// Log the writers before adding a new item.
lock (this.writers)
{
// Use a Tuple so we can provide a lock object.
this.writers.Add(new Tuple<ILogWriter, object>(writer, new object()));
}
}
/// <summary>
/// Flushes the log that has not yet been sent and disposes the logging infrastructure
/// </summary>
void DisposeLogger ()
{
if (currentLogWriter != null) {
flushTimer.Dispose ();
flushTimer = null;
FlushLog ();
currentLogWriter = null;
}
}
public LogCollector(IQueued<LogItem> qThread, ILogWriter writer)
{
this.writer = writer;
filterQue = new ConcurrentQueue<Action<HashSet<int>>>();
filter = new HashSet<int>();
this.qThread = qThread;
qThread.SetTimeout(writer.GetTimeout());
qThread.OnReceive += Receive;
qThread.OnTimeout += TimeOut;
}
/// <summary>
/// Dumps the elements with HTML source.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="logWriter">The log writer.</param>
public static void DumpElementsWithHtmlSource(Document document, ILogWriter logWriter)
{
logWriter.LogAction("Dump:==================================================");
IHTMLElementCollection elements = elementCollection(document);
foreach (IHTMLElement e in elements)
{
logWriter.LogAction("------------------------- " + e.id);
logWriter.LogAction(e.outerHTML);
}
}
public MSBuildResult[] RunTarget (string target, string configuration, string platform, ILogWriter logWriter,
MSBuildVerbosity verbosity)
{
if (target == null)
throw new ArgumentNullException ("target");
if (configuration == null)
throw new ArgumentNullException ("configuration");
return builder.RunTarget (target, configuration, platform, logWriter, verbosity);
}
public MainForm()
{
InitializeComponent();
_Spinner.Image = Properties.Resources.spinner;
_userLog = new LogWriterListView(_logListView);
Task.Run(() => Init());
Closing += OnClose;
}
/// <summary>
/// 将数据发送到业务系统中
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
public void PostMessage(string url, string data, ILogWriter _log)
{
//发送消息到回调接口
if (string.IsNullOrEmpty(url))
{
_log.Info("CenterInterface配置为空");
return;
}
_log.Info($"{DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss fff")} 回调{url}接口。");
//实例化
NewWebClient client = new NewWebClient();
//参数转流
byte[] bytearray = Encoding.UTF8.GetBytes(data);
//采取POST方式必须加的header，如果改为GET方式的话就去掉这句话即可
client.Headers.Add("Content-Type", "application/json;charset=UTF-8");
client.Headers.Add("ContentLength", bytearray.Length.ToString());//长度
//上传，post方式，并接收返回数据（这是同步，需要等待接收返回值）
try
{
byte[] responseData = client.UploadData(url, "POST", bytearray);
//释放
client.Dispose();
//处理返回数据
string rel = Encoding.UTF8.GetString(responseData);
if (!string.IsNullOrEmpty(rel))
{
_log.Info($"{DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss fff")} 回调{url}接口返回内容：{rel}");
}
}
catch (Exception ex)
{
_log.Info($"发送Post数据时出错：{ex.Message}");
}
}
public FunctionInstanceLogger(
Func <string, FunctionDescriptor> funcLookup,
IMetricsLogger metrics,
string hostName,
string accountConnectionString, // May be null
TraceWriter trace) : this(funcLookup, metrics)
{
if (trace == null)
{
throw new ArgumentNullException(nameof(trace));
}
if (accountConnectionString != null)
{
CloudStorageAccount account = CloudStorageAccount.Parse(accountConnectionString);
var client = account.CreateCloudTableClient();
var tableProvider = LogFactory.NewLogTableProvider(client);
string containerName = Environment.MachineName;
this._writer = LogFactory.NewWriter(hostName, containerName, tableProvider, (e) => OnException(e, trace));
}
}
private int Test_Get_GetList(ILogWriter writer, int count)
{
Guid guid = Guid.NewGuid();
DateTime t1 = DateTime.Now;
DateTime t2 = DateTime.Now;
try {
writer.Get <ExceptionInfo>(guid);
}
catch (NotImplementedException) {
count++;
}
try {
writer.GetList <ExceptionInfo>(t1, t2);
}
catch (NotImplementedException) {
count++;
}
return(count);
}
internal static void Write(this ILogWriter writer,
NetworkStream readStream,
long checkpointSize)
{
var blockSize = 1024 * 1024;
var buffer = new byte[blockSize];
while (checkpointSize > 0)
{
int bytesRead;
if (checkpointSize >= blockSize)
{
bytesRead = readStream.Read(buffer, 0, blockSize);
}
else
{
bytesRead = readStream.Read(buffer, 0, (int)checkpointSize);
}
writer.Write(buffer, 0, bytesRead);
checkpointSize -= bytesRead;
}
}
public FunctionInstanceLogger(
IFunctionMetadataManager metadataManager,
IProxyMetadataManager proxyMetadataManager,
IMetricsLogger metrics,
IHostIdProvider hostIdProvider,
IConfiguration configuration,
ILoggerFactory loggerFactory)
: this(metadataManager, proxyMetadataManager, metrics)
{
if (hostIdProvider == null)
{
throw new ArgumentNullException(nameof(hostIdProvider));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
string accountConnectionString = configuration.GetWebJobsConnectionString(ConnectionStringNames.Dashboard);
if (accountConnectionString != null)
{
CloudStorageAccount account = CloudStorageAccount.Parse(accountConnectionString);
var client = account.CreateCloudTableClient();
var tableProvider = LogFactory.NewLogTableProvider(client);
ILogger logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryHostGeneral);
string hostId = hostIdProvider.GetHostIdAsync(CancellationToken.None).GetAwaiter().GetResult() ?? "default";
string containerName = Environment.MachineName;
_writer = LogFactory.NewWriter(hostId, containerName, tableProvider, (e) => OnException(e, logger));
}
}
public AsyncQueueLogWriter(ILogWriter logWriter, int batchSize, TimeSpan writeTimeout, ILogEventFilter filter) : base(filter)
{
if (logWriter == null)
{
throw new ArgumentNullException(nameof(logWriter));
}
_BatchSize = batchSize;
_WriteTimeout = writeTimeout;
if (writeTimeout.TotalMilliseconds > 0)
{
_BufferTimeoutTimer = new System.Threading.Timer((reserved) => SetWriteEventsSignal(), null, TimeSpan.Zero, TimeSpan.Zero);
}
_WriteBufferedEventsSignal = new System.Threading.ManualResetEvent(false);
_BufferedLogEvents = new System.Collections.Concurrent.ConcurrentQueue <LogEvent>();
_LogWriter = logWriter;
//TODO: Start thread that does write here.
//TODO: Implement IDisposable.
}
public NodeLogger(
[NotNull] IParametersParser parametersParser,
[NotNull] ILogWriter logWriter,
[NotNull] ILoggerContext context,
[NotNull] IEnvironment environment,
[NotNull] IDiagnostics diagnostics,
[NotNull] IBuildEventHandler <BuildStartedEventArgs> buildStartedHandler,
[NotNull] IBuildEventHandler <BuildMessageEventArgs> messageHandler,
[NotNull] IBuildEventHandler <BuildFinishedEventArgs> buildFinishedHandler,
[NotNull] IBuildEventHandler <ProjectStartedEventArgs> projectStartedHandler,
[NotNull] IBuildEventHandler <ProjectFinishedEventArgs> projectFinishedHandler,
[NotNull] IBuildEventHandler <TargetStartedEventArgs> targetStartedHandler,
[NotNull] IBuildEventHandler <TargetFinishedEventArgs> targetFinishedHandler,
[NotNull] IBuildEventHandler <TaskStartedEventArgs> taskStartedHandler,
[NotNull] IBuildEventHandler <TaskFinishedEventArgs> taskFinishedHandler,
[NotNull] IBuildEventHandler <BuildErrorEventArgs> errorHandler,
[NotNull] IBuildEventHandler <BuildWarningEventArgs> warningHandler,
[NotNull] IBuildEventHandler <CustomBuildEventArgs> customEventHandler)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_environment = environment ?? throw new ArgumentNullException(nameof(environment));
_diagnostics = diagnostics ?? throw new ArgumentNullException(nameof(diagnostics));
_parametersParser = parametersParser ?? throw new ArgumentNullException(nameof(parametersParser));
_logWriter = logWriter ?? throw new ArgumentNullException(nameof(logWriter));
_buildStartedEventHandler = buildStartedHandler ?? throw new ArgumentNullException(nameof(buildStartedHandler));
_messageHandler = messageHandler ?? throw new ArgumentNullException(nameof(messageHandler));
_buildFinishedHandler = buildFinishedHandler ?? throw new ArgumentNullException(nameof(buildFinishedHandler));
_projectStartedHandler = projectStartedHandler ?? throw new ArgumentNullException(nameof(projectStartedHandler));
_projectFinishedHandler = projectFinishedHandler ?? throw new ArgumentNullException(nameof(projectFinishedHandler));
_targetStartedHandler = targetStartedHandler ?? throw new ArgumentNullException(nameof(targetStartedHandler));
_targetFinishedHandler = targetFinishedHandler ?? throw new ArgumentNullException(nameof(targetFinishedHandler));
_taskStartedHandler = taskStartedHandler ?? throw new ArgumentNullException(nameof(taskStartedHandler));
_taskFinishedHandler = taskFinishedHandler ?? throw new ArgumentNullException(nameof(taskFinishedHandler));
_errorHandler = errorHandler ?? throw new ArgumentNullException(nameof(errorHandler));
_warningHandler = warningHandler ?? throw new ArgumentNullException(nameof(warningHandler));
_customEventHandler = customEventHandler ?? throw new ArgumentNullException(nameof(customEventHandler));
}
protected override void InternalStart()
{
lock (this)
{
var logManagerTracer = SetupTracerFactory.TracerFor(this);
if (_logWriters.Count > 0)
{
logManagerTracer.Debug("Stopping LogManager before re-starting it...");
Stop();
}
foreach (ILogWriterConfig logWriterConfig in Config.Writers)
{
if (_logWriters.ContainsKey(logWriterConfig))
{
// Occurs when the logWriterConfig already exists - this shouldn't happen
var tracer = SetupTracerFactory.TracerFor(logWriterConfig);
tracer.Severe("LogWriterConfig {0} is already active - this shouldn't happen. Skipping it...", logWriterConfig);
continue;
}
ILogWriter logWriter = CreateLogWriter(logWriterConfig);
if (logWriter != null)
{
(logWriter as IStartable).SafeStart(SetupTracerFactory);
_logWriters.Add(logWriterConfig, logWriter);
if (logWriterConfig.DisposeOnStop)
{
DisposeOnStop(logWriter);
}
}
}
}
}
/// <summary>
/// get a writer
/// </summary>
/// <param name="level"></param>
/// <param name="name"></param>
/// <returns></returns>
public virtual ILogWriter GetWriter(LogLevel level, string name)
{
ILogWriter writer = null;
lock (this.writerDictionary)
{
if (this.writerDictionary.TryGetValue(name, out writer) == false)
{
writer = new LogAgentWriter(level, name);
writer.Writing += this.OnWriting;
writer.Disposed += this.OnDisposed;
//
if (this.levelFlags > 0)
{
writer.Enable = (this.levelFlags & (int)level) == (int)level;
}
//
this.writerDictionary.Add(name, writer);
}
}
//
return(writer);
}
// ILogWriter logWriter, IEnumerable<ILogEventContextProvider> contextProviders, ILogClock logClock
public Logger(LogPolicy policy)
{
if (policy == null)
{
throw new ArgumentNullException(nameof(policy));
}
if (policy.LogWriter == null)
{
throw new ArgumentException("policy.LogWriter cannot be null", nameof(policy));
}
_EntryPool = new LogEventPool();
_LogWriter = policy.LogWriter;
_LogClock = policy.Clock;
_Filter = policy.Filter;
if (policy.ContextProviders != null)
{
_ContextProviders = (policy.ContextProviders as ILogEventContextProvider[]) ?? policy.ContextProviders.ToArray();
}
_IsEnabled = true;
}
private void SetExceptionWriter()
{
if (string.IsNullOrEmpty(_config.ExceptionWriter) == false)
{
string writerTypeName = null;
if (_writerNameTypeDict.TryGetValue(_config.ExceptionWriter, out writerTypeName))
{
// 保存写日志发生异常的Writer，单个实例
try {
Type t = Type.GetType(writerTypeName, true);
ILogWriter instance = (ILogWriter)Activator.CreateInstance(t); // 测试类型是否符合要求
_writersTable[WriterFactory.ExceptionWriterKey] = t;
}
catch (Exception ex) {
throw new LogConfigException("日志配置文件中，指定的Writer无效：" + writerTypeName, ex);
}
}
else
{
throw new LogConfigException("日志配置文件中，指定的Writer无效：" + _config.ExceptionWriter);
}
}
}
private void ReplaceDb(string pathToDbFile, ILogWriter applicationLog, Exception exception)
{
string backupFileName = string.Format(
"{0}_{1}.invalid",
pathToDbFile,
DateTime.UtcNow.ToString("yyyy-MM-ddThh-mm-ss"));
File.Copy(pathToDbFile, backupFileName);
File.Delete(pathToDbFile);
this.CreateNewDb(pathToDbFile);
applicationLog.AddEntry(
new LogEntry(
MessageLevel.Warning,
ClassName,
string.Format(
"Invalid database file found at {0}. Replacement file created.{1}Error:{2}",
pathToDbFile,
Environment.NewLine,
exception.Message)));
}
/// <inheritdoc />
public void RemoveWriter(ILogWriter writer)
{
Tuple <ILogWriter, object> toRemove = null;
// Log the writers before removing the item.
lock (this.writers)
{
// Enumerate and find the correct writer pair.
foreach (var keyValuePair in this.writers)
{
if (keyValuePair.Item1 == writer)
{
toRemove = keyValuePair;
break;
}
}
// Remove the Tuple if we found one.
if (toRemove != null)
{
this.writers.Remove(toRemove);
}
}
}
private bool QueryPointcut <TPointcut, TItem>(
ILogWriter logger,
IDictionary <AssemblyDefinition, TypeDefinition[]> asmTypes,
KeyValuePair <PointcutExpression, IPointcut> pointcut,
Func <TypeDefinition[], TPointcut, IEnumerable <TItem> > queryAction,
Func <IEnumerable <TItem>, IEnumerable <CodeTree.TypeNode> > createTypeNodes
) where TPointcut : class, IPointcut
{
var tPointcut = pointcut.Value as TPointcut;
if (tPointcut == null)
{
return(false);
}
Dictionary <AssemblyDefinition, TItem[]> filteredAsmTypes;
try
{
logger.Append("STARTED: executing pointcut '{0}'...", tPointcut.Name);
filteredAsmTypes = asmTypes.AsParallel().ToDictionary(
asmType => asmType.Key,
asmType => queryAction(asmType.Value, tPointcut).ToArray());
logger.Append("COMPLETED: executing pointcut '{0}'", tPointcut.Name);
}
catch (Exception e)
{
logger.Append("ERROR executing pointcut '{0}'. Reason: '{1}'", tPointcut.Name, e.Message);
filteredAsmTypes = asmTypes.ToDictionary(x => x.Key, x => new TItem[0]);
}
_treeDispatcher.BeginInvoke(new Action(() =>
_result.AddPointcut(tPointcut,
string.Format("[{0}(\"{1}\")]", pointcut.Key.AttributeName, pointcut.Key.Saql),
filteredAsmTypes.Select(x => new CodeTree.AssemblyNode(x.Key, createTypeNodes(x.Value))))));
return(true);
}
private async Task ReadImageFileIntoStream(
Stream outputStream,
Stream inputStream,
List <byte> boundaryStartLine,
int imageDataStartPosition,
ILogWriter logger)
{
// inputStream should at this point be positioned at the start of the actual image data
// in the multipart content. Calculate where the image data actually ends, by calculating
// where the multipard end-line begins.
long lastPositionToRead = inputStream.Length - (boundaryStartLine.Count + 4);
logger.LogInformation($"First byte of image data is at {imageDataStartPosition}, last byte is at {lastPositionToRead}");
// read photo file content into memory stream
byte[] buffer = new byte[8 * KBYTE];
long currentPos = imageDataStartPosition;
int readBytes;
do
{
// Calculate size of next chunk to read. Read 8 KB if there is more than
// 8 KB left to read, otherwise read whatever is left
int nextChunkSize = (int)Math.Min(8 * KBYTE, lastPositionToRead - currentPos);
// Read next chunk of data, making note of how much we actually got
readBytes = await inputStream.ReadAsync(buffer, 0, nextChunkSize);
// Write the bytes that we got onto the output stream
await outputStream.WriteAsync(buffer, 0, readBytes);
// Advance the position counter
currentPos += readBytes;
} while (currentPos < lastPositionToRead);
logger.LogInformation($"Image read into memory. currentPos = '{currentPos}'");
}
private void LoadWritersType()
{
if (_config.Writers == null || _config.Writers.Length == 0)
{
throw new LogConfigException("日志配置文件中，没有配置Writers节点。");
}
foreach (var w in _config.Writers)
{
if (string.IsNullOrEmpty(w.Name))
{
throw new LogConfigException("日志配置文件中，写入器的 Name 属性不能为空。");
}
if (string.IsNullOrEmpty(w.Type))
{
throw new LogConfigException("日志配置文件中，写入器的 Type 属性不能为空。");
}
// 如果指定的类型不正确，下面代码会抛出异常
Type t = Type.GetType(w.Type, true);
if (typeof(ILogWriter).IsAssignableFrom(t) == false)
{
throw new LogConfigException("日志配置文件中，指定的WriteType没有实现接口ILogWriter：" + w.Type);
}
ILogWriter instance = Activator.CreateInstance(t) as ILogWriter;
instance.Init(w);
_writerNameTypeDict[w.Name] = w.Type;
}
// 增加一个内置的，可用于开发环境中不写日志
_writerNameTypeDict["NULL"] = "ClownFish.Log.Serializer.NullWriter, ClownFish.Log";
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpClientContext"/> class.
/// </summary>
/// <param name="secured">true if the connection is secured (SSL/TLS)</param>
/// <param name="remoteEndPoint">client that connected.</param>
/// <param name="stream">Stream used for communication</param>
/// <param name="clientCertificate">Client security certificate</param>
/// <param name="parserFactory">Used to create a <see cref="IHttpRequestParser"/>.</param>
/// <param name="bufferSize">Size of buffer to use when reading data. Must be at least 4096 bytes.</param>
/// <param name="socket">Client socket</param>
/// <exception cref="SocketException">If <see cref="Socket.BeginReceive(byte[],int,int,SocketFlags,AsyncCallback,object)"/> fails</exception>
/// <exception cref="ArgumentException">Stream must be writable and readable.</exception>
public HttpClientContext(bool secured, IPEndPoint remoteEndPoint, Stream stream,
ClientCertificate clientCertificate, IRequestParserFactory parserFactory, int bufferSize, Socket socket)
{
Check.Require(remoteEndPoint, "remoteEndPoint");
Check.NotEmpty(remoteEndPoint.Address.ToString(), "remoteEndPoint.Address");
Check.Require(stream, "stream");
Check.Require(parserFactory, "parser");
Check.Min(4096, bufferSize, "bufferSize");
Check.Require(socket, "socket");
if (!stream.CanWrite || !stream.CanRead)
{
throw new ArgumentException("Stream must be writable and readable.");
}
_bufferSize = bufferSize;
RemoteAddress = remoteEndPoint.Address.ToString();
RemotePort = remoteEndPoint.Port.ToString();
_log = NullLogWriter.Instance;
_parser = parserFactory.CreateParser(_log);
_parser.RequestCompleted += OnRequestCompleted;
_parser.RequestLineReceived += OnRequestLine;
_parser.HeaderReceived += OnHeaderReceived;
_parser.BodyBytesReceived += OnBodyBytesReceived;
_localEndPoint = (IPEndPoint)socket.LocalEndPoint;
HttpRequest request = new HttpRequest();
request._remoteEndPoint = remoteEndPoint;
request.Secure = secured;
_currentRequest = request;
IsSecured = secured;
_stream = stream;
_clientCertificate = clientCertificate;
_buffer = new byte[bufferSize];
}
public ReportsModule(IServiceLocator locator)
{
_locator = locator;
var logger = locator.GetInstance <ILogWriter>();
var regionManager = locator.GetInstance <IRegionManager>();
var pluginTracker = locator.GetInstance <IPluginModuleTracker>();
var eventAggregator = locator.GetInstance <IEventAggregator>();
if (logger == null)
{
throw new NullReferenceException("logger of type \"ILoggerFacade\" is required and should not be null.");
}
if (regionManager == null)
{
throw new NullReferenceException("regionManager should not be null.");
}
if (pluginTracker == null)
{
throw new NullReferenceException("pluginTracker should not be null.");
}
if (eventAggregator == null)
{
throw new NullReferenceException("Event Aggregator should not be null.");
}
_logger = logger;
_regionManager = regionManager;
_pluginTracker = pluginTracker;
_pluginTracker.RecordModuleConstructed(this.GetType().Assembly.GetName().Name);
_eventAggregator = eventAggregator;
// Register the views in this module.
//_regionManager.RegisterViewWithRegion("DataSetListView", typeof(Views.DataSetListView));
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityImporter{TStrategy, TEntity, TKey}"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="sessionFactoryProvider">The session factory provider.</param>
/// <param name="dataproviders">The dataproviders.</param>
/// <param name="configurationService">The configuration service.</param>
protected EntityImporter(ILogWriter logger
, [Import(RequiredCreationPolicy = CreationPolicy.NonShared)]
IDomainSessionFactoryProvider sessionFactoryProvider
, IEnumerable <IDataReaderDictionary> dataproviders
, IConfigurationService configurationService)
{
Logger = logger;
SessionFactory = sessionFactoryProvider.SessionFactory;
SessionProvider = sessionFactoryProvider;
FirstImport = false;
EntityStrategy = new TStrategy();
var max = dataproviders.Max(d => d.VersionAttribute.Version);
DataProvider = dataproviders.FirstOrDefault(d => d.VersionAttribute.Version == max);
ConfigurationService = configurationService;
EventAggregator = ServiceLocator.Current.GetInstance <IEventAggregator>();
OnFeedback += (sender, args) =>
{
if (!IsBackground)
{
EventAggregator.GetEvent <MessageUpdateEvent>()
.Publish(new MessageUpdateEvent {
Message = args.Data.ToString()
});
}
else
{
EventAggregator.GetEvent <UiMessageUpdateEventForeGround>()
.Publish(new UiMessageUpdateEventForeGround()
{
Message = args.Data.ToString()
});
}
};
}
public ConfigurationModule(IServiceLocator locator)
{
var logger = locator.GetInstance <ILogWriter>();
var regionManager = locator.GetInstance <IRegionManager>();
var pluginTracker = locator.GetInstance <IPluginModuleTracker>();
var configurationService = locator.GetInstance <IConfigurationService>();
if (logger == null)
{
throw new NullReferenceException("logger of type \"ILoggerFacade\" is required and should not be null.");
}
if (regionManager == null)
{
throw new NullReferenceException("regionManager should not be null.");
}
if (configurationService == null)
{
throw new NullReferenceException("logger of type \"IConfigurationService\" is required and should not be null.");
}
if (pluginTracker == null)
{
throw new NullReferenceException("pluginTracker should not be null.");
}
_logger = logger;
_regionManager = regionManager;
_configurationService = configurationService;
_pluginTracker = pluginTracker;
_pluginTracker.RecordModuleConstructed(GetType().Assembly.GetName().Name);
// Register the views in this module.
//_regionManager.RegisterViewWithRegion("DataSetListView", typeof(Views.DataSetListView));
}
static void Main(string[] args)
{
string warningText = "warning by";
string errorText = "error by";
string infoText = "info by";
string stringSeparator = " ";
ILogWriter consoleLogWriter = SingletoneConsoleLogWriter.GetConsoleLogWriterInstance();
consoleLogWriter.LogWarning(warningText + stringSeparator + nameof(consoleLogWriter));
consoleLogWriter.LogError(errorText + stringSeparator + nameof(consoleLogWriter));
consoleLogWriter.LogInfo(infoText + stringSeparator + nameof(consoleLogWriter));
ILogWriter fileLogWriter = SingletoneFileLogWriter.GetFileLogWriterInstance();
fileLogWriter.LogWarning(warningText + stringSeparator + nameof(fileLogWriter));
fileLogWriter.LogError(errorText + stringSeparator + nameof(fileLogWriter));
fileLogWriter.LogInfo(infoText + stringSeparator + nameof(fileLogWriter));
ILogWriter oneMoreConsoleWriter = SingletoneConsoleLogWriter.GetConsoleLogWriterInstance();
ILogWriter oneMoreFileWriter = SingletoneFileLogWriter.GetFileLogWriterInstance();
List <ILogWriter> LogWriterList = new List <ILogWriter>
{
oneMoreConsoleWriter,
oneMoreFileWriter
};
ILogWriter multipleLogWriter = SingletoneMultipleLogWriter.GetMultipleLogWriterInstance();
SingletoneMultipleLogWriter.GetMultipleLogWriterInstance().LogWriterList = LogWriterList;
multipleLogWriter.LogWarning(warningText + stringSeparator + nameof(multipleLogWriter));
multipleLogWriter.LogError(errorText + stringSeparator + nameof(multipleLogWriter));
multipleLogWriter.LogInfo(infoText + stringSeparator + nameof(multipleLogWriter));
System.Console.ReadKey();
}
/// <summary>
/// Initializes a new instance of the <see cref="LoginListView"/> class.
/// </summary>
/// <param name="source">The source.</param>
public LoginListView(List <Login> source, ILogWriter logWriter)
: base("Аккаунты", source)
{
_logWriter = logWriter;
Sites = EnumHelper.GetData(typeof(Site));
ContextMenu.Add(new MenuItem
{
Header = "Войти на сайт",
Command = new DelegateCommand(DoLogon, HasSelection)
});
ContextMenu.Add(new MenuItem
{
Header = "Очистить объявы",
Command = new DelegateCommand(DoClear, HasSelection)
});
ContextMenu.Add(new MenuItem
{
Header = "Поднять объявы",
Command = new DelegateCommand(DoUp, HasSelection)
});
}
public ILogWriter CreateProxyFor(ILogWriter innerLogWriter, int maxQueueLength = DefaultMaxQueueLength)
{
Contract.Requires <ArgumentNullException>(innerLogWriter != null);
Contract.Requires <ArgumentException>(maxQueueLength > 0);
lock (this)
{
EnsureNotDisposed();
OperationNotSupportedWhenStarted("CreateProxyFor(ILogWriter)");
var logWriter = new LogWriterProxy(innerLogWriter, _backgroundActionQueue, _setupTracerFactory);
foreach (var kvp in innerLogWriter.EntryWriters)
{
Type entryWriterEntryType = kvp.Key;
object innerEntryWriter = kvp.Value;
var entryTypeArgs = new Type[] { entryWriterEntryType };
object blockingQueueEntryWriter = this.InvokeGenericMethod(entryTypeArgs, "CreateBlockingQueueLogWriter", innerEntryWriter, maxQueueLength);
logWriter.InvokeGenericMethod(entryTypeArgs, "AddEntryWriter", blockingQueueEntryWriter);
}
_proxyLogWriters.Add(logWriter);
return(logWriter);
}
}
private static void SearchWriter()
{
if (_hasSearched)
{
return;
}
_hasSearched = true;
//search all assemblies for ILogWriter
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var a in assemblies)
{
Type[] types;
try
{
types = a.GetExportedTypes();
}
catch (ReflectionTypeLoadException e)
{
types = e.Types.Where(t => t != null).ToArray();
}
var writerType = typeof(ILogWriter);
var type = types.FirstOrDefault(t => !t.IsAbstract && writerType.IsAssignableFrom(t));
if (type == null)
{
continue;
}
_logWriter = Activator.CreateInstance(type) as ILogWriter;
return;
}
}
private void ProcessFlushException(List <Exception> exceptions)
{
if (exceptions.Count > 0)
{
ILogWriter retryLogger = WriterFactory.GetRetryWriter(); // 获取重试日志序列化器
if (retryLogger != null)
{
try {
List <ExceptionInfo> list = (from x in exceptions select ExceptionInfo.Create(x)).ToList();
retryLogger.Write(list);
}
catch (Exception ex) {
LogHelper.RaiseErrorEvent(ex);
}
}
else
{
foreach (Exception ex in exceptions)
{
LogHelper.RaiseErrorEvent(ex);
}
}
}
}
/// <summary>
/// 注册日志记录器
/// </summary>
/// <param name="writer"></param>
/// <param name="identifier"></param>
/// <returns></returns>
public static bool RegisterWriter(ILogWriter writer, string identifier)
{
if (writer == null || string.IsNullOrWhiteSpace(identifier))
{
return(false);
}
identifier = identifier.ToLower();
if (_queueDict.ContainsKey(identifier))
{
return(false);
}
Queue <LogInfo> infoQueue = new Queue <LogInfo>();
_queueDict.Add(identifier, infoQueue);
ThreadPool.QueueUserWorkItem(i =>
{
while (true)
{
if (infoQueue.Count > 0)
{
lock (infoQueue)
{
LogInfo logInfo = infoQueue.Dequeue();
writer.WriteLog(logInfo.Message, logInfo.LogLevel);
}
}
else
{
Thread.Sleep(100);
}
}
});
return(true);
}
static void Main(string[] args)
{
string warningText = "warning by";
string errorText = "error by";
string infoText = "info by";
string stringSeparator = " ";
LogWriterFactory factory = LogWriterFactory.GetLogWriterFactoryInstance();
ILogWriter consoleLogWriter = factory.GetLogWriter <ConsoleLogWriter>(null);
consoleLogWriter.LogWarning(warningText + stringSeparator + consoleLogWriter.GetType());
consoleLogWriter.LogError(errorText + stringSeparator + consoleLogWriter.GetType());
consoleLogWriter.LogInfo(infoText + stringSeparator + consoleLogWriter.GetType());
ILogWriter fileLogWriter = factory.GetLogWriter <FileLogWriter>($"log.txt");
fileLogWriter.LogWarning(warningText + stringSeparator + fileLogWriter.GetType());
fileLogWriter.LogError(errorText + stringSeparator + fileLogWriter.GetType());
fileLogWriter.LogInfo(infoText + stringSeparator + fileLogWriter.GetType());
ILogWriter oneMoreConsoleWriter = new ConsoleLogWriter();
ILogWriter oneMoreFileWriter = new FileLogWriter($"log.txt");
List <ILogWriter> LogWriterList = new List <ILogWriter>
{
oneMoreConsoleWriter,
oneMoreFileWriter
};
ILogWriter multipleLogWriter = factory.GetLogWriter <MultipleLogWriter>(LogWriterList);
multipleLogWriter.LogWarning(warningText + stringSeparator + multipleLogWriter.GetType());
multipleLogWriter.LogError(errorText + stringSeparator + multipleLogWriter.GetType());
multipleLogWriter.LogInfo(infoText + stringSeparator + multipleLogWriter.GetType());
}
public UserController(ILogWriter log, IBusinessAccess businessAccess)
{
_log = log;
_businessAccess = businessAccess;
}
// Write logs. Return what we wrote.
// This is baseline data. REader will verify against it exactly. This helps in aggressively catching subtle breaking changes.
private async Task WriteTestLoggingDataAsync(ILogTableProvider provider)
{
ILogWriter writer = LogFactory.NewWriter(HostName, "c1", provider);
string Func1 = "alpha";
var time = new DateTime(2010, 3, 6, 18, 11, 20, DateTimeKind.Utc);
List <FunctionInstanceLogItem> list = new List <FunctionInstanceLogItem>();
List <InvocationLogViewModel> expected = new List <InvocationLogViewModel>();
this.ExpectedItems = expected;
this.Data = list;
// List in reverse chronology.
// Completed Success
{
var item = new FunctionInstanceLogItem
{
FunctionInstanceId = Guid.NewGuid(),
FunctionName = Func1,
StartTime = time,
EndTime = time.AddMinutes(2), // Completed
LogOutput = "one",
};
list.Add(item);
expected.Add(new InvocationLogViewModel
{
id = item.FunctionInstanceId.ToString(),
status = "CompletedSuccess",
whenUtc = "2010-03-06T18:13:20Z", // since it's completed, specifies end-time
duration = 120000.0
});
}
// Completed Error
{
time = time.AddMinutes(-1);
var item = new FunctionInstanceLogItem
{
FunctionInstanceId = Guid.NewGuid(),
FunctionName = Func1,
StartTime = time,
EndTime = time.AddMinutes(2),
ErrorDetails = "some failure", // signifies failure
LogOutput = "two",
};
list.Add(item);
expected.Add(new InvocationLogViewModel
{
id = item.FunctionInstanceId.ToString(),
status = "CompletedFailed",
whenUtc = "2010-03-06T18:12:20Z", // end-time.
duration = 120000.0
});
}
// Still running
{
time = time.AddMinutes(-1);
var item = new FunctionInstanceLogItem
{
FunctionInstanceId = Guid.NewGuid(),
FunctionName = Func1,
StartTime = time, // Recent heartbeat
LogOutput = "two",
};
list.Add(item);
expected.Add(new InvocationLogViewModel
{
id = item.FunctionInstanceId.ToString(),
status = "Running",
whenUtc = "2010-03-06T18:09:20Z", // specifies start-time
});
}
// Never Finished
{
time = time.AddMinutes(-1);
var item = new TestFunctionInstanceLogItem
{
FunctionInstanceId = Guid.NewGuid(),
FunctionName = Func1,
StartTime = time, // Never Finished
LogOutput = "two",
OnRefresh = (me) => { me.FunctionInstanceHeartbeatExpiry = time; }, // stale heartbeat
};
list.Add(item);
expected.Add(new InvocationLogViewModel
{
id = item.FunctionInstanceId.ToString(),
status = "NeverFinished",
whenUtc = "2010-03-06T18:08:20Z", // starttime
duration = null
});
}
// No heartbeat (legacy example)
{
time = time.AddMinutes(-1);
var item = new TestFunctionInstanceLogItem
{
FunctionInstanceId = Guid.NewGuid(),
FunctionName = Func1,
StartTime = time, // Never Finished
LogOutput = "two",
OnRefresh = (me) => { } // No heart beat
};
list.Add(item);
expected.Add(new InvocationLogViewModel
{
id = item.FunctionInstanceId.ToString(),
status = "Running",
whenUtc = "2010-03-06T18:07:20Z", // starttime
});
}
foreach (var item in list)
{
await writer.AddAsync(item);
}
await writer.FlushAsync();
}
public MetadataDefinitionGroupController(ICommandDispatcher dispatcher, IMetadataDefinitonGroupReadService metadataDefinitonGroupReadService, ILogWriter logWriter)
{
_dispatcher = dispatcher;
_metadataDefinitonGroupReadService = metadataDefinitonGroupReadService;
_logWriter = logWriter;
}
