protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var reqLog = new { Method = request.Method, Url = request.RequestUri.AbsoluteUri, Headers = request.Headers, Body = await request.Content.ReadAsStringAsync() }; Logger.DebugFormat("HTTP Request\n{0}", LogSerializer.Serialize(reqLog)); var response = await base.SendAsync(request, cancellationToken); string body = ""; if (response.Content != null) { body = await response.Content.ReadAsStringAsync(); } var respLog = new { StatusCode = response.StatusCode, Headers = response.Headers, Body = body }; Logger.DebugFormat("HTTP Response\n{0}", LogSerializer.Serialize(respLog)); return(response); }
private void LogWarn(string message) { var validationLog = new TokenRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(validationLog); Logger.WarnFormat("{0}\n {1}", message, json); }
/// <summary> /// Saves an error log on disk. /// </summary> /// <param name="exception">The exception that caused the crash.</param> /// <param name="errorLog">The error log.</param> public virtual void InstanceSaveErrorLogFiles(System.Exception exception, ManagedErrorLog errorLog) { try { // Serialize main log file. var errorLogString = LogSerializer.Serialize(errorLog); var errorLogFileName = errorLog.Id + ErrorLogFileExtension; AppCenterLog.Debug(Crashes.LogTag, "Saving uncaught exception."); var directory = InstanceGetErrorStorageDirectory(); directory.CreateFile(errorLogFileName, errorLogString); AppCenterLog.Debug(Crashes.LogTag, $"Saved error log in directory {ErrorStorageDirectoryName} with name {errorLogFileName}."); try { // Serialize exception as raw stack trace. var exceptionFileName = errorLog.Id + ExceptionFileExtension; directory.CreateFile(exceptionFileName, exception.ToString()); AppCenterLog.Debug(Crashes.LogTag, $"Saved exception in directory {ErrorStorageDirectoryName} with name {exceptionFileName}."); } catch (System.Exception ex) { AppCenterLog.Warn(Crashes.LogTag, "Failed to serialize exception for client side inspection.", ex); } } catch (System.Exception ex) { AppCenterLog.Error(Crashes.LogTag, "Failed to save error log.", ex); } }
private void LogError(string message) { var log = new EndSessionRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(log); Logger.ErrorFormat("{0}\n{1}", message, json); }
private void LogSuccess() { var log = new EndSessionRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(log); Logger.InfoFormat("{0}\n{1}", "End session request validation success", json); }
private void LogSuccess() { var validationLog = new TokenRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(validationLog); Logger.InfoFormat("{0}\n {1}", "Token request validation success", json); }
internal async Task EnsureConfigurationAsync(CancellationToken cancellationToken) { await EnsureProviderInformationAsync(cancellationToken); _logger.LogTrace("Effective options:"); _logger.LogTrace(LogSerializer.Serialize(Options)); }
public async Task SaveLargeLogDoesNotPurgeOtherLogsWhenStorageIsFull() { // Set storage max size. var capacity = 12 * 1024; var setMaxStorageSizeResult = await _storage.SetMaxStorageSizeAsync(capacity); Assert.IsTrue(setMaxStorageSizeResult); // Put 2 logs into databse. var logs = PutNLogs(2); // Try to put large log into databse and verify that StorageException exception was trown. var largeLogSize = capacity + 1; var largeLog = CreateLogWithSize(largeLogSize); try { await _storage.PutLog(StorageTestChannelName, largeLog); } catch (StorageException e) { var logJsonString = LogSerializer.Serialize(largeLog); var logSize = Encoding.UTF8.GetBytes(logJsonString).Length; Assert.AreEqual(e.Message, $"Log is too large ({logSize} bytes) to store in database. Current maximum database size is {capacity} bytes."); } // Verify that logs in databse were not deleted. var retrievedLogs = new List <Log>(); await _storage.GetLogsAsync(StorageTestChannelName, int.MaxValue, retrievedLogs); CollectionAssert.Contains(retrievedLogs, logs[0]); CollectionAssert.Contains(retrievedLogs, logs[1]); CollectionAssert.DoesNotContain(retrievedLogs, largeLog); }
private string LogEvent(string message) { var validationLog = new TokenRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(validationLog); return(string.Format("{0}\n {1}", message, json)); }
private void LogError(string message, ValidatedAuthorizeRequest request) { var validationLog = new AuthorizeRequestValidationLog(request); var json = LogSerializer.Serialize(validationLog); Logger.ErrorFormat("{0}\n {1}", message, json); }
public void SaveBinaryExceptionDoesNotThrow(Type exceptionType) { var errorLog = new ManagedErrorLog { Id = Guid.NewGuid(), ProcessId = 123 }; var exception = exceptionType.GetConstructor(Type.EmptyTypes)?.Invoke(null) as System.Exception; var errorLogFilename = errorLog.Id + ".json"; var serializedErrorLog = LogSerializer.Serialize(errorLog); var exceptionFilename = errorLog.Id + ".exception"; var mockDirectory = Mock.Of <Directory>(); var mockStream = new System.IO.MemoryStream(); Mock.Get(mockDirectory).Setup(d => d.FullName).Returns("Errors"); // Cause stream to fail writing mockStream.Dispose(); // Given we succeed saving log file but fail saving exception file. ErrorLogHelper.Instance._crashesDirectory = mockDirectory; // When we save files. ErrorLogHelper.SaveErrorLogFiles(exception, errorLog); // Then it does not throw. Mock.Get(mockDirectory).Verify(d => d.CreateFile(errorLogFilename, serializedErrorLog)); Mock.Get(mockDirectory).Verify(d => d.CreateFile(exceptionFilename, exception.ToString())); }
private void LogSuccess(ValidatedAuthorizeRequest request) { var validationLog = new AuthorizeRequestValidationLog(request); var json = LogSerializer.Serialize(validationLog); Logger.InfoFormat("{0}\n {1}", "Authorize request validation success", json); }
private string CreateLogsContent(IList <Log> logs) { var logContainer = new LogContainer(logs); // Serialize request. var requestContent = LogSerializer.Serialize(logContainer); return(requestContent); }
/// <summary> /// Raises the specified event. /// </summary> /// <param name="evt">The event.</param> /// <exception cref="System.ArgumentNullException">evt</exception> public virtual Task PersistAsync(Event evt) { if (evt == null) throw new ArgumentNullException(nameof(evt)); var json = LogSerializer.Serialize(evt); _logger.LogInformation(json); return Task.CompletedTask; }
// Creates a new instance of MobileCenter private MobileCenter() { lock (MobileCenterLock) { _applicationSettings = _applicationSettingsFactory?.CreateApplicationSettings() ?? new DefaultApplicationSettings(); LogSerializer.AddLogType(StartServiceLog.JsonIdentifier, typeof(StartServiceLog)); LogSerializer.AddLogType(CustomPropertiesLog.JsonIdentifier, typeof(CustomPropertiesLog)); } }
private Func <string> LogEvent(string message) { return(() => { var validationLog = new TokenRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(validationLog); return message + "\n " + json; }); }
// Creates a new instance of AppCenter private AppCenter() { lock (AppCenterLock) { _applicationSettings = _applicationSettingsFactory?.CreateApplicationSettings() ?? new DefaultApplicationSettings(); LogSerializer.AddLogType(StartServiceLog.JsonIdentifier, typeof(StartServiceLog)); LogSerializer.AddLogType(CustomPropertyLog.JsonIdentifier, typeof(CustomPropertyLog)); ApplicationLifecycleHelper.Instance.UnhandledExceptionOccurred += OnUnhandledExceptionOccurred; } }
private static async Task LogResponse(IOwinResponse response) { var respLog = new { StatusCode = response.StatusCode, Headers = response.Headers, Body = await response.ReadBodyAsStringAsync() }; Logger.Debug("HTTP Response" + Environment.NewLine + LogSerializer.Serialize(respLog)); }
/// <summary> /// Asynchronously adds a log to storage /// </summary> /// <param name="channelName">The name of the channel associated with the log</param> /// <param name="log">The log to add</param> /// <exception cref="StorageException"/> public async Task PutLogAsync(string channelName, Log log) { using (await _taskLockSource.GetTaskLockAsync().ConfigureAwait(false)) { var logJsonString = LogSerializer.Serialize(log); var logEntry = new LogEntry { Channel = channelName, Log = logJsonString }; await _storageAdapter.InsertAsync(logEntry).ConfigureAwait(false); } }
private async Task FillDatabaseWithLogs(int storageCapacity) { var log = TestLog.CreateTestLog(); var logJsonString = LogSerializer.Serialize(log); var logSize = Encoding.UTF8.GetBytes(logJsonString).Length; var logsCount = storageCapacity / logSize; var logs = PutNLogs(logsCount - 1); logs.Add(log); await _storage.PutLog(StorageTestChannelName, log); }
/// <summary> /// Raises the specified event. /// </summary> /// <param name="evt">The event.</param> /// <exception cref="System.ArgumentNullException">evt</exception> public virtual void Raise <T>(Event <T> evt) { if (evt == null) { throw new ArgumentNullException("evt"); } var json = LogSerializer.Serialize(evt); Logger.Info(json); }
/// <summary> /// Asynchronously adds a log to storage /// </summary> /// <param name="channelName">The name of the channel associated with the log</param> /// <param name="log">The log to add</param> /// <exception cref="StorageException"/> public Task PutLog(string channelName, Log log) { return(AddTaskToQueue(() => { var logJsonString = LogSerializer.Serialize(log); var logEntry = new LogEntry { Channel = channelName, Log = logJsonString }; _storageAdapter.InsertAsync(logEntry).GetAwaiter().GetResult(); })); }
/// <summary> /// Loads the data from the Install Log file. /// </summary> private void LoadPluginLog() { m_ostActivePlugins.Clear(); if (LogSerializer != null) { foreach (string strPlugin in LogSerializer.LoadPluginLog()) { m_ostActivePlugins.Add(ManagedPluginRegistry.GetPlugin(strPlugin)); } } }
/// <summary> /// Asynchronously adds a log to storage /// </summary> /// <param name="channelName">The name of the channel associated with the log</param> /// <param name="log">The log to add</param> /// <exception cref="StorageException"/> public Task PutLog(string channelName, Log log) { return(AddTaskToQueue(() => { var logJsonString = LogSerializer.Serialize(log); _storageAdapter.Insert(TableName, new[] { ColumnChannelName, ColumnLogName }, new List <object[]> { new object[] { channelName, logJsonString } }); })); }
private static async Task LogRequest(IOwinRequest request) { var reqLog = new { Method = request.Method, Url = request.Uri.AbsoluteUri, Headers = request.Headers, Body = await request.ReadBodyAsStringAsync() }; Logger.Debug("HTTP Request" + Environment.NewLine + LogSerializer.Serialize(reqLog)); }
/// <summary> /// Asynchronously retrieves logs from storage and flags them to avoid duplicate retrievals on subsequent calls /// </summary> /// <param name="channelName">Name of the channel to retrieve logs from</param> /// <param name="limit">The maximum number of logs to retrieve</param> /// <param name="logs">A list to which the retrieved logs will be added</param> /// <returns>A batch ID for the set of returned logs; null if no logs are found</returns> /// <exception cref="StorageException"/> public Task <string> GetLogsAsync(string channelName, int limit, List <Log> logs) { return(AddTaskToQueue(() => { logs?.Clear(); var retrievedLogs = new List <Log>(); AppCenterLog.Debug(AppCenterLog.LogTag, $"Trying to get up to {limit} logs from storage for {channelName}"); var idPairs = new List <Tuple <Guid?, long> >(); var failedToDeserializeALog = false; var objectEntries = _storageAdapter.Select(TableName, ColumnChannelName, channelName, ColumnIdName, _pendingDbIdentifiers.Cast <object>().ToArray(), limit); var retrievedEntries = objectEntries.Select(entries => new LogEntry() { Id = (long)entries[0], Channel = (string)entries[1], Log = (string)entries[2] } ).ToList(); foreach (var entry in retrievedEntries) { try { var log = LogSerializer.DeserializeLog(entry.Log); retrievedLogs.Add(log); idPairs.Add(Tuple.Create(log.Sid, Convert.ToInt64(entry.Id))); } catch (JsonException e) { AppCenterLog.Error(AppCenterLog.LogTag, "Cannot deserialize a log in storage", e); failedToDeserializeALog = true; _storageAdapter.Delete(TableName, ColumnIdName, entry.Id); } } if (failedToDeserializeALog) { AppCenterLog.Warn(AppCenterLog.LogTag, "Deleted logs that could not be deserialized"); } if (idPairs.Count == 0) { AppCenterLog.Debug(AppCenterLog.LogTag, $"No available logs in storage for channel '{channelName}'"); return null; } // Process the results var batchId = Guid.NewGuid().ToString(); ProcessLogIds(channelName, batchId, idPairs); logs?.AddRange(retrievedLogs); return batchId; })); }
/// <summary> /// Raises the specified event. /// </summary> /// <param name="evt">The event.</param> /// <exception cref="System.ArgumentNullException">evt</exception> public virtual Task PersistAsync(Event evt) { if (evt == null) { throw new ArgumentNullException(nameof(evt)); } var json = LogSerializer.Serialize(evt); _logger.LogInformation(json); return(Task.FromResult(0)); }
/// <summary> /// Reads an error log file from the given file. /// </summary> /// <param name="file">The file that contains error log.</param> /// <returns>An error log instance or null if the file doesn't contain an error log.</returns> public virtual ManagedErrorLog InstanceReadErrorLogFile(File file) { try { var errorLogString = file.ReadAllText(); return((ManagedErrorLog)LogSerializer.DeserializeLog(errorLogString)); } catch (System.Exception e) { AppCenterLog.Error(Crashes.LogTag, $"Encountered an unexpected error while reading an error log file: {file.Name}", e); } return(null); }
/// <summary> /// Raises the specified event. /// </summary> /// <param name="evt">The event.</param> /// <exception cref="ArgumentNullException">evt</exception> public virtual Task RaiseAsync <T>(Event <T> evt) { if (evt == null) { throw new ArgumentNullException("evt"); } var json = LogSerializer.Serialize(evt); Logger.Info(json); return(Task.FromResult(0)); }
/// <summary> /// Asynchronously retrieves logs from storage and flags them to avoid duplicate retrievals on subsequent calls /// </summary> /// <param name="channelName">Name of the channel to retrieve logs from</param> /// <param name="limit">The maximum number of logs to retrieve</param> /// <param name="logs">A list to which the retrieved logs will be added</param> /// <returns>A batch ID for the set of returned logs; null if no logs are found</returns> /// <exception cref="StorageException"/> public Task <string> GetLogsAsync(string channelName, int limit, List <Log> logs) { return(AddTaskToQueue(() => { logs?.Clear(); var retrievedLogs = new List <Log>(); AppCenterLog.Debug(AppCenterLog.LogTag, $"Trying to get up to {limit} logs from storage for {channelName}"); var idPairs = new List <Tuple <Guid?, long> >(); var failedToDeserializeALog = false; var retrievedEntries = _storageAdapter.GetAsync <LogEntry>(entry => entry.Channel == channelName, limit) .GetAwaiter().GetResult(); foreach (var entry in retrievedEntries) { if (_pendingDbIdentifiers.Contains(entry.Id)) { continue; } try { var log = LogSerializer.DeserializeLog(entry.Log); retrievedLogs.Add(log); idPairs.Add(Tuple.Create(log.Sid, Convert.ToInt64(entry.Id))); } catch (JsonException e) { AppCenterLog.Error(AppCenterLog.LogTag, "Cannot deserialize a log in storage", e); failedToDeserializeALog = true; _storageAdapter.DeleteAsync <LogEntry>(row => row.Id == entry.Id) .GetAwaiter().GetResult(); } } if (failedToDeserializeALog) { AppCenterLog.Warn(AppCenterLog.LogTag, "Deleted logs that could not be deserialized"); } if (idPairs.Count == 0) { AppCenterLog.Debug(AppCenterLog.LogTag, $"No available logs in storage for channel '{channelName}'"); return null; } // Process the results var batchId = Guid.NewGuid().ToString(); ProcessLogIds(channelName, batchId, idPairs); logs?.AddRange(retrievedLogs); return batchId; })); }