/// <summary>
/// Performs a simple write to the event log.
/// </summary>
/// <param name="logRequest">The log request.</param>
/// <returns>The response to the request.</returns>
public LogResponse Log(LogRequest logRequest)
{
using (Profiler.Measure("CastActivityService.Log"))
{
var response = new LogResponse();
try
{
if (logRequest == null)
{
throw new ArgumentNullException("logRequest");
}
if (!CastService.GetIsCastConfigured())
{
throw new InvalidOperationException();
}
EventLog.Application.WriteInformation(logRequest.Message);
response.Time = DateTime.UtcNow;
}
catch (Exception e)
{
response.IsError = true;
response.Error = e.Message;
}
return(response);
}
}
public IActionResult Write([FromBody] LogRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var logFactory = _logFactoryStorage.GetLogFactoryOrDefault(request.AppName);
if (logFactory == null)
{
_log.Warning(nameof(Write), $"Logger for appName {request.AppName} not found", context: request);
return(BadRequest(ErrorResponse.Create($"Logger for appName {request.AppName} not found")));
}
var logInformation = request.MapToLogInformationDto();
if (request.LogLevel == LogLevelContract.Monitor)
{
var healthNotifier = _healthNotifierStorage.GetOrCreateHealthNotifier(request.AppName,
request.AppVersion,
request.EnvInfo,
logFactory);
_healthNotificationWriter.SendNotification(healthNotifier, logInformation);
return(Ok());
}
_logWriter.Write(logFactory, request.LogLevel.MapToMicrosoftLoglevel(), logInformation);
return(Ok());
}
/// <summary>
/// Generates an analytics package and sends it to the Clearcut servers.
/// </summary>
/// <param name="analyticsHost">Address of host to send the analytics to.</param>
/// <param name="logRequest">Data to send to the analytics server.</param>
public void SendAnalytics(string analyticsHost, LogRequest logRequest)
{
// Save the time sending was last attempted.
_lastUpdateTicks = DateTime.Now.Ticks;
// Only send if analytics is enabled.
if (EnableAnalytics == false)
{
return;
}
// Only allow one instance of the request at a time.
if (_webRequest != null)
{
return;
}
// Send the data to the server.
UnityWebRequest webRequest = new UnityWebRequest(analyticsHost);
webRequest.method = UnityWebRequest.kHttpVerbPOST;
webRequest.uploadHandler = new UploadHandlerRaw(logRequest.ToByteArray());
webRequest.downloadHandler = new DownloadHandlerBuffer();
webRequest.SetRequestHeader("Content-Type", "application/x-protobuf");
webRequest.SendWebRequest();
// The editor callback will follow through with this request.
_webRequest = webRequest;
}
public void Query(out string pageHtml)
{
pageHtml = string.Empty;
var request = new LogRequest();
if (request.PageIndex == null || request.PageIndex <= 0)
{
request.PageIndex = 1;
}
if (request.PageSize == null || request.PageSize <= 0)
{
request.PageSize = 10;
}
if (this.LogType != Globals.All)
{
request.LogType = LogType;
}
request.ContentWith = Content;
request.UserName = UserName;
var query = LogService.NewQuery(request);
this.List = query.ModelList.ToList(this, x => new ListLog(x));
if (query != null)
{
pageHtml = MvcPage.AjaxPager((int)request.PageIndex, (int)request.PageSize, query.TotalCount);
}
}
// GET: LogRequests/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LogRequest logRequest = db.LogRequests.Find(id);
if (logRequest == null)
{
return(HttpNotFound());
}
ViewBag.log_citizenId = new SelectList(db.Citizens, "citizen_id", "citizen_national_id", logRequest.log_citizenId);
ViewBag.log_requestId = new SelectList(db.Requests, "request_id", "address", logRequest.log_requestId);
ViewBag.log_request_typeId = new SelectList(db.TypeRequests, "typeReaquest_id", "typeReaquest_name", logRequest.log_request_typeId);
if (Session["lang"] != null)
{
if (Session["lang"].ToString().Equals("ar-EG"))
{
ViewBag.log_citizenId = new SelectList(db.Citizens, "citizen_id", "citizen_national_id", logRequest.log_citizenId);
ViewBag.log_requestId = new SelectList(db.Requests, "request_id", "address_arabic", logRequest.log_requestId);
ViewBag.log_request_typeId = new SelectList(db.TypeRequests, "typeReaquest_id", "typeReaquest_name_arabic", logRequest.log_request_typeId);
}
}
return(View(logRequest));
}
private Task <NullResponse> SaveItem(LogRequest request, LogLevel level)
{
return(Task.Run(() =>
{
var item = new LogInfo()
{
Level = level,
FileName = request.FileName,
LineNumber = request.LineNumber,
EventID = request.EventID,
MethodEventID = request.MethodEventID,
MethodID = request.TimeStamp,
TimeStamp = request.TimeStamp,
TraceID = request.TraceID,
MethodName = request.MethodName,
Message = request.Message,
};
if (request.CustomData != null)
{
var keys = request.CustomData.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
item.CustomData.Add(keys[i], request.CustomData[keys[i]]);
}
}
_dbInstance.SaveItem(item);
return new NullResponse();
}));
}
public void Stop()
{
_tcpClient.Close();
_stream.Close();
LogRequest?.Invoke(this, new LogEventArgs("Client writer stopped."));
}
public ActionResult Create([Bind(Include = "log_request_id,log_requestId,log_citizenId,log_date,log_request_typeId")] LogRequest logRequest)
{
if (ModelState.IsValid)
{
db.LogRequests.Add(logRequest);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.log_citizenId = new SelectList(db.Citizens, "citizen_id", "citizen_national_id", logRequest.log_citizenId);
ViewBag.log_requestId = new SelectList(db.Requests, "request_id", "address", logRequest.log_requestId);
ViewBag.log_request_typeId = new SelectList(db.TypeRequests, "typeReaquest_id", "typeReaquest_name", logRequest.log_request_typeId);
if (Session["lang"] != null)
{
if (Session["lang"].ToString().Equals("ar-EG"))
{
ViewBag.log_citizenId = new SelectList(db.Citizens, "citizen_id", "citizen_national_id", logRequest.log_citizenId);
ViewBag.log_requestId = new SelectList(db.Requests, "request_id", "address_arabic", logRequest.log_requestId);
ViewBag.log_request_typeId = new SelectList(db.TypeRequests, "typeReaquest_id", "typeReaquest_name_arabic", logRequest.log_request_typeId);
}
}
return(View(logRequest));
}
private static void LogToDB(LogRequest request)
{
Serilog.Log.Write(
ConvertTo_SerilogLogLevel(request.Level),
"{source}{timestamp}{level}{method}{machineName}{message}{exception}{parameters}{activityId}",
request.Source,
request.TimeStamp,
request.Level,
request.Method,
request.MachineName,
request.Message,
request.Exception,
ParametersSerializer.Serialize(request.Parameters),
request.ActivityId);
LogEventLevel ConvertTo_SerilogLogLevel(string logLevel)
{
switch (logLevel.ToLower())
{
case "info": return(LogEventLevel.Information);
default:
throw new NotImplementedException($"Mapping for {logLevel} is not implemented.");
}
}
}
public async Task <bool> Execute(string pathIn, string pathOut)
{
try
{
var stringBuilder = new StringBuilder();
// Processando arquivo de entrada.
var retrived = await _transformerService.ExecuteProcess(pathIn);
// Obtendo as estatísticas do arquivo de entrada.
var fileLine = await _reportService.GetStats(retrived);
stringBuilder.AppendLine(fileLine.GetDescription(_format));
stringBuilder.AppendLine(fileLine.ToString(_format));
var logRequest = new LogRequest
{
Path = pathOut,
Content = stringBuilder
};
//Salvando arquivo de saída.
var logResponse = await _writer.SaveData(logRequest);
return(logResponse.Result);
}
catch (Exception)
{
return(false);
}
}
public void Write(string title, string detail, LogEventType logEventType)
{
var request = new LogRequest();
request.Guid = Guid.NewGuid();
request.LogEvent = new LogEvent();
request.LogEvent.Header = new LogEventHeader();
request.LogEvent.Header.AppId = this.AppId;
request.LogEvent.Header.LogEventType = logEventType;
request.LogEvent.Header.Source = this.SourceClassName;
request.LogEvent.Header.CreateTime = DateTime.Now;
request.LogEvent.Body = new LogEventBody();
request.LogEvent.Body.Title = title;
request.LogEvent.Body.Detail = detail;
LogResponse response = null;
try
{
response = ServiceClient.WriteLog(request);
//Console.WriteLine(response.Message);
}
catch (FaultException <FaultData> fault)
{
//Console.WriteLine(fault.Message);
//Console.WriteLine(fault.Detail.Message);
}
catch (Exception)
{
//Console.WriteLine(ex.ToString());
}
}
private void ProcessRequest(HttpContext context)
{
IHeaderDictionary headers = context.Request.Headers;
string urlReferrer = headers.SafeGet("Referer");
string url = context.Request.GetDisplayUrl();
LogRequest logRequestBase = new LogRequest()
{
UserAgent = headers.SafeGet("User-Agent"),
UserHostAddress = context.Connection.RemoteIpAddress.ToString(),
Url = urlReferrer ?? url,
Headers = headers.ConvertHeadersToDictionary()
};
string httpMethod = context.Request.Method;
string json;
using (StreamReader reader = new StreamReader(context.Request.Body, Encoding.UTF8))
{
json = reader.ReadToEnd();
}
LogResponse response = _loggingService.ProcessLogRequest(json, logRequestBase, httpMethod);
ToHttpResponse(response, context.Response);
}
private async Task SaveLogs(List <ILogModel> logsToSave)
{
if (logsToSave != null && logsToSave.Count > 0)
{
string url = $"{ApiHost}/api/log/bulk";
LogRequest req = new LogRequest()
{
Logs = logsToSave
};
try
{
using (HttpClient client = new HttpClient())
{
string json = JsonConvert.SerializeObject(req, Formatting.Indented);
var response = await client.PostAsync(url, new StringContent(json, Encoding.UTF8, "application/json"));
if (response.StatusCode == HttpStatusCode.BadRequest)
{
//fallback method of writing logs to a file
}
else if (response.StatusCode == HttpStatusCode.Created)
{
}
}
}
catch (Exception ex)
{
lock (_listLock)
{
_failures.Add(ex);
}
}
}
}
public LogResponse WriteLog(LogRequest request)
{
LogResponse response = new LogResponse();
try
{
var message = new MessageBase <LogEvent>();
message.Guid = request.Guid;
message.Content = request.LogEvent;
msmq.Enqueue(message);
response.Message = string.Format("Message {0} is in queue now.", request.Guid);
}
catch (Exception ex)
{
LocalLog.Error(ex.ToString());
var fault = new FaultData {
Message = ex.ToString()
};
var reason = new FaultReason("WriteLog发生异常");
throw new FaultException <FaultData>(fault, reason);
}
return(response);
}
public virtual void Log(LogRequest e)
{
if (LogItemReceived != null)
{
LogItemReceived(this, e);
}
}
// PUBLIC METHODS
#region public methods
#region Start()
public void Start(int port)
{
ThreadPool.QueueUserWorkItem(_ =>
{
_tcpClient = new TcpClient("127.0.0.1", port);
LogRequest?.Invoke(this, new LogEventArgs("Connection was established...."));
_stream = _tcpClient.GetStream();
Byte[] response = new Byte[_tcpClient.ReceiveBufferSize];
while (_listening)
{
int bytesRead = _stream.Read(response, 0, (int)_tcpClient.ReceiveBufferSize);
if (bytesRead > 0)
{
string returnData = Encoding.UTF8.GetString(response, 0, bytesRead);
LogRequest?.Invoke(this, new LogEventArgs("Server Response: " + returnData));
if (returnData == "q")
{
_listening = false;
}
}
}
_tcpClient.Close();
_stream.Close();
LogRequest?.Invoke(this, new LogEventArgs("Client reader stopped."));
});
}
public async Task RequestLogging_Handler(SQSEvent Event)
{
try
{
Logger.Log("Enter");
foreach (var MyMessage in Event.Records)
{
LogRequest MyLoggingRequest = MyMessage.Body.DeserializeJSON <LogRequest>();
if (MyLoggingRequest.xTimestamp.IsNullOrWhiteSpace())
{
MyLoggingRequest.xTimestamp = DateTime.UtcNow.ToISO8601(MillisecondPrecision: 6);
}
string MyPath = $"{MyLoggingRequest.xService}/{MyLoggingRequest.xRefNum}/{MyLoggingRequest.xTimestamp}_{MyLoggingRequest.xDataLabel}{GetObjectExtension(MyLoggingRequest.xDataType)}";
await modIS3.S3_Upload_Async(modAWS.AWS_USWest2_DevCard(), MyS3Bucket, MyPath, MyLoggingRequest.xData.GetBytes());
}
}
catch (Exception Ex)
{
Logger.LogException_LogOnly(Ex);
}
finally
{
Logger.Log("Exit");
}
}
}// ProcessOutMessage()
//
//
// *************************************************************
// **** Get New LogEvent() ****
// *************************************************************
/// <summary>
/// When the outside thread wants to make a request, he calls this method which
/// rather than creating new event, simply takes the next one from off a stack of event args.
/// The hub thread returns used eventArgs back to the stack after ProcessOutMessage().
/// </summary>
/// <param name="req"></param>
/// <param name="message"></param>
/// <param name="timeElapsed"></param>
/// <returns></returns>
protected LogEventArgs GetNewLogEvent(LogRequest req, string message, LogLevel level, TimeSpan timeElapsed)
{
// Get an empty eventArg object
LogEventArgs eventArg;
int n;
lock (m_EventStorageLock)
{
n = m_EventStorage.Count;
if (n > 0)
{
eventArg = m_EventStorage.Dequeue();
}
else
{
eventArg = new LogEventArgs();
}
}
// Load the eventArg object
eventArg.Request = req;
eventArg.Level = level;
eventArg.Message = message;
eventArg.TimeElapsedFromStart = timeElapsed;
eventArg.LastCount = n; // number of eventARgs in storage. For debugging.
return(eventArg);
}//
public async Task Invoke(HttpContext context)
{
var requestBodyStream = new MemoryStream();
var originalRequestBody = context.Request.Body;
await context.Request.Body.CopyToAsync(requestBodyStream);
requestBodyStream.Seek(0, SeekOrigin.Begin);
var url = UriHelper.GetDisplayUrl(context.Request);
var requestBodyText = new StreamReader(requestBodyStream).ReadToEnd();
// Create new Request Model
LogRequest r = new LogRequest();
r.method = context.Request.Method;
r.body = requestBodyText;
r.url = url;
r.created = DateTime.UtcNow;
dbcontext.Requests.Add(r);
dbcontext.SaveChanges();
//_logger.Log(LogLevel.Information, 1, $"REQUEST METHOD: {context.Request.Method}, REQUEST BODY: {requestBodyText}, REQUEST URL: {url}", null);
requestBodyStream.Seek(0, SeekOrigin.Begin);
context.Request.Body = requestBodyStream;
await next(context);
context.Request.Body = originalRequestBody;
}
private bool CreateFileInRelativePath(LogRequest logRequest)
{
var directory = new DirectoryInfo(logRequest.Path);
if (!directory.Exists)
{
Directory.CreateDirectory(logRequest.Path);
}
FileInfo file;
var fileName = "";
var versionFile = 0;
var files = directory.GetFiles().Select(i => i.Name);
do
{
fileName = string.Format(_fileName, ++versionFile);
file = new FileInfo(Path.Combine(logRequest.Path, fileName));
} while (files.Any(i => i.Contains(fileName)));
File.WriteAllText(file.ToString(), logRequest.Content.ToString());
return(!file.Exists);
}
private async Task LoadLogAsync()
{
logLoadError = null;
var logRequest = new LogRequest();
var fromTime = GetFromTime();
if (!fromTime.HasValue)
{
return;
}
logRequest.FromTime = fromTime.Value.ToUnixTimeSeconds();
logRequest.ToTime = fromTime.Value.AddSeconds((int)(logRequestForm?.Model != null ? logRequestForm.Model.TimeInterval : LogTimeIntervals.FifteenMinutes)).ToUnixTimeSeconds();
if (logRequestForm?.Model != null)
{
logRequest.Filter = logRequestForm.Model.Filter;
logRequest.QueryExceptions = logRequestForm.Model.QueryTypes.Contains(LogQueryTypes.Exceptions);
logRequest.QueryTraces = logRequestForm.Model.QueryTypes.Contains(LogQueryTypes.Traces);
logRequest.QueryEvents = logRequestForm.Model.QueryTypes.Contains(LogQueryTypes.Events);
logRequest.QueryMetrics = logRequestForm.Model.QueryTypes.Contains(LogQueryTypes.Metrics);
}
else
{
logRequest.QueryExceptions = true;
logRequest.QueryEvents = true;
}
logResponse = (await TrackService.GetTrackLogAsync(logRequest)).Map <LogResponseViewModel>();
}
/// <summary>
/// Handles logging of the message to Loupe
/// </summary>
/// <param name="logRequest">A request received from the agent to log information</param>
public virtual void Log(LogRequest logRequest)
{
if (logRequest.LogMessages is null || logRequest.LogMessages.Count == 0)
{
return;
}
var detailsBlockBuilder = new LogMessageBlockBuilder(logRequest);
var sourceProvider = new JavaScriptSourceProvider();
foreach (var logMessage in logRequest.LogMessages)
{
var jsException = CreateJavaScriptException(logMessage);
var detailsBlock = detailsBlockBuilder.Build(logMessage);
var messageSource = sourceProvider.ProcessMessage(logMessage);
_log.Write(logMessage.Severity,
"Loupe",
messageSource,
logRequest.User,
jsException,
LogWriteMode.Queued,
detailsBlock,
logMessage.Category,
logMessage.Caption,
logMessage.Description,
logMessage.Parameters);
}
}
public LogResponse ProcessLogRequest(string json, LogRequest logRequest, string httpMethod)
{
LogResponse response = new LogResponse();
if ((httpMethod != WebRequestMethods.Http.Post) && (httpMethod != "OPTIONS"))
{
response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
return(response);
}
response.StatusCode = (int)HttpStatusCode.OK;
if (httpMethod == "OPTIONS")
{
response.Headers.Add("Allow", WebRequestMethods.Http.Post);
return(response);
}
LogClientRequest clientRequest = JsonConvert.DeserializeObject <LogClientRequest>(json);
LogData logData = new LogData()
{
LoggerName = clientRequest.LoggerName ?? LogCategories.GENERAL,
LogLevel = clientRequest.LogLevel,
Message = clientRequest.Message
};
Log(logData);
return(response);
}
private Uri BuildReqEndpoint(LogRequest request)
{
//use empty string as project name if not set (expection will be thrown when do request)
string project = request.IsSetProject() ? request.Project : String.Empty;
return(new Uri(this._uriScheme + "://" + project + "." + this._hostName + ":" + this._port));
}
public ActionResult GetAllLogs()
{
var _draw = Request.Form.GetValues("draw").FirstOrDefault();
var _start = Request.Form.GetValues("start").FirstOrDefault();
var _length = Request.Form.GetValues("length").FirstOrDefault();
var _sortColumn = Request.Form.GetValues("columns[" + Request.Form.GetValues("order[0][column]").FirstOrDefault() + "][name]").FirstOrDefault();
var _sortColumnDir = Request.Form.GetValues("order[0][dir]").FirstOrDefault();
var _searchValue = Request.Form.GetValues("search[value]").FirstOrDefault();
int _pageSize = _length != null?Convert.ToInt32(_length) : 0;
int _skip = _start != null?Convert.ToInt32(_start) : 0;
var request = new LogRequest
{
Draw = _draw,
SearchValue = _searchValue,
SortColumn = _sortColumn,
SortColumnDir = _sortColumnDir,
PageSize = _pageSize,
Skip = _skip
};
var response = new LogHandler(_unitOfWork).GetListData(request);
return(Json(new { data = response.Data, recordsFiltered = response.RecordsFiltered, recordsTotal = response.RecordsTotal, draw = response.Draw }, JsonRequestBehavior.AllowGet));
}
public void Constructor_InitializesProperties()
{
var request = new LogRequest(LogLevel.Minimal, message: "a");
Assert.Equal(LogLevel.Minimal, request.LogLevel);
Assert.Equal("a", request.Message);
}
/// <summary>
/// Handles logging of the message to Loupe
/// </summary>
/// <param name="logRequest">A request received from the agent to log information</param>
public virtual void Log(LogRequest logRequest)
{
var detailsBlockBuilder = new LogMessageBlockBuilder(logRequest);
var sourceProvider = new JavaScriptSourceProvider();
foreach (var logMessage in logRequest.LogMessages)
{
var jsException = CreateJavaScriptException(logMessage);
var detailsBlock = detailsBlockBuilder.Build(logMessage);
var messageSource = sourceProvider.ProcessMessage(logMessage);
Gibraltar.Agent.Log.Write(logMessage.Severity,
"Loupe",
messageSource,
"",
jsException,
LogWriteMode.Queued,
detailsBlock,
logMessage.Category,
logMessage.Caption,
logMessage.Description,
logMessage.Parameters);
}
}
public IActionResult Log([FromBody] LogRequest request)
{
var machine = _dbContext.Machines.AsTracking().FirstOrDefault(m => m.Key.Equals(request.Key));
if (machine == null)
{
machine = CreateMachine();
}
var set = new KeyPressSet()
{
MachineId = machine.Id,
KeyPresses = request.Keys.Select(k => new Domain.KeyPress()
{
Code = k.Code,
From = k.From,
To = k.To,
DataType = k.DataType,
Data = k.Data
}).ToList()
};
_dbContext.KeyPressSets.Add(set);
_dbContext.SaveChanges();
return(Ok(machine.Key));
}
public async Task <LogResponse> SaveData(LogRequest logRequest)
{
var result = false;
try
{
Console.Write(logRequest.Content.ToString());
var fileInfo = new FileInfo(logRequest.Path);
if (fileInfo.Attributes == FileAttributes.Directory)
{
result = CreateFileInRelativePath(logRequest);
}
else
{
result = CreateFileInFullPath(logRequest);
}
return(await Task.FromResult(new LogResponse { Result = result }));
}
catch (Exception ex)
{
return(await Task.FromResult(new LogResponse { Result = result }));
}
}
private async Task <LogResponse> LogMessageAsync(LogRequest request)
{
try
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
switch (request.Level)
{
case LogLevel.Debug:
{
await Log4netLogger.Instance.LogDebugAsync(request.Message);
break;
}
case LogLevel.Error:
{
await Log4netLogger.Instance.LogErrorAsync(request.Message);
break;
}
case LogLevel.Fatal:
{
await Log4netLogger.Instance.LogFatalAsync(request.Message);
break;
}
case LogLevel.Info:
{
await Log4netLogger.Instance.LogInformationAsync(request.Message);
break;
}
case LogLevel.Warn:
{
await Log4netLogger.Instance.LogWarningAsync(request.Message);
break;
}
default:
{
return(new LogResponse(false, $"Log level {request.Level} is not supported!"));
}
}
return(new LogResponse(true, "Message was logged succesfully!"));
}
catch (Exception ex)
{
return(new LogResponse(false, $"An error occurred trying to log debug message: {ex.ToExceptionMessage()}"));
}
}
private static FinalLogData ProcessLogItem(LogRequestSingleMsg logItem, LogRequestBase logRequestBase,
DateTime serverSideTimeUtc, JsnlogConfiguration jsnlogConfiguration)
{
string serversideLoggerNameOverride = jsnlogConfiguration.serverSideLogger;
string messageFormat = jsnlogConfiguration.serverSideMessageFormat;
string levelOverride = jsnlogConfiguration.serverSideLevel;
string dateFormat = jsnlogConfiguration.dateFormat;
try
{
LevelUtils.ValidateLevel(levelOverride);
}
catch (Exception e)
{
throw new PropertyException("levelOverride", e);
}
// ----------------
string message = logItem.m;
string logger = logItem.n;
string level = logItem.l; // note that level as sent by the javascript is a number
DateTime utcDate = DateTime.UtcNow;
string timestampMs = logItem.t;
try
{
double ms = double.Parse(timestampMs);
utcDate = DateTime.SpecifyKind((new DateTime(1970, 1, 1)).AddMilliseconds(ms), DateTimeKind.Utc);
}
catch
{
}
// ----------------
string jsonmessage = "";
if (messageFormat.Contains("%jsonmessage"))
{
jsonmessage = LogMessageHelpers.EnsureValidJson(message);
}
// ----------------
var logRequest = new LogRequest(message, logger, level, utcDate, jsonmessage, logRequestBase);
var loggingEventArgs = new LoggingEventArgs(logRequest)
{
Cancel = false,
ServerSideMessageFormat = messageFormat
};
// ----------------
if (string.IsNullOrWhiteSpace(logger)) { logger = Constants.RootLoggerNameServerSide; }
loggingEventArgs.FinalLogger = serversideLoggerNameOverride ?? logger;
string consolidatedLevel = levelOverride ?? level;
loggingEventArgs.FinalLevel = LevelUtils.ParseLevel(consolidatedLevel).Value;
// ----------------
loggingEventArgs.FinalMessage = messageFormat
.Replace("%message", message)
.Replace("%jsonmessage", jsonmessage)
.Replace("%utcDateServer", serverSideTimeUtc.ToString(dateFormat))
.Replace("%utcDate", utcDate.ToString(dateFormat))
.Replace("%dateServer", Utils.UtcToLocalDateTime(serverSideTimeUtc).ToString(dateFormat))
.Replace("%date", Utils.UtcToLocalDateTime(utcDate).ToString(dateFormat))
.Replace("%level", level)
.Replace("%newline", System.Environment.NewLine)
.Replace("%userAgent", logRequestBase.UserAgent)
.Replace("%userHostAddress", logRequestBase.UserHostAddress)
.Replace("%requestId", logRequestBase.RequestId ?? "")
.Replace("%url", logRequestBase.Url)
.Replace("%logger", logger);
// ----------------
JavascriptLogging.RaiseLoggingEvent(loggingEventArgs);
// If user wrote event handler that decided not to log the message, return null
if (loggingEventArgs.Cancel) { return null; }
return loggingEventArgs;
}
public RequestLoggingServiceBehavior(LogRequest logger)
{
_logCallback = logger;
}
/// <summary>
/// Returns true to indicate that the process can be shut down.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public bool ProcessCompleted (TestHarnessCompletedEventArgs e, Action onCompleted)
{
string msg;
try {
if (filename == null)
return true;
if (writer != null)
writer.Flush ();
msg = text.ToString ();
if (string.IsNullOrEmpty (msg))
return true;
LogRequest request = new LogRequest ();
request.provider = this;
request.uri = new Uri (baseuri + "MoonLogProvider.aspx?filename=" + filename, UriKind.Absolute);
object _o = WebRequest.Create (request.uri);
Console.WriteLine (_o.GetType());
request.httprequest = (HttpWebRequest) _o;
//request.httprequest = (HttpWebRequest) WebRequest.Create (request.uri);
request.httprequest.Method = "POST";
request.httprequest.ContentType = "text/xml";// "application/x-www-form-urlencoded";
request.message = msg + Environment.NewLine;
// This cwl is required, the test harness looks for it in stdout to find
// the filename we write to.
Console.WriteLine ("MoonLogProvider: sending request to: {0}", request.uri);
request.httprequest.BeginGetRequestStream (RequestCallback, request);
on_completed = onCompleted;
return false;
} catch (Exception ex) {
Console.WriteLine ("Exception while trying to send result: {0}", ex.ToString ());
return true;
}
}
public void AddLogger(LogRequest logger)
{
_logCallback += logger;
}
