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)); }
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); }
/// <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); } }
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 LogSuccess() { var log = new EndSessionRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(log); Logger.InfoFormat("{0}\n{1}", "End session request validation success", json); }
private void LogWarn(string message) { var validationLog = new TokenRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(validationLog); Logger.WarnFormat("{0}\n {1}", message, 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)); }
private void LogError(string message) { var log = new EndSessionRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(log); Logger.ErrorFormat("{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); }
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; }
private Func <string> LogEvent(string message) { return(() => { var validationLog = new TokenRequestValidationLog(_validatedRequest); var json = LogSerializer.Serialize(validationLog); return message + "\n " + json; }); }
/// <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); }
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)); }
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> /// 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); } }
/// <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> /// 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> /// 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> /// 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)); }
public override bool Equals(object obj) { var that = obj as TestLog; if (that == null) { return(false); } var thisSerialized = LogSerializer.Serialize(this); var thatSerialized = LogSerializer.Serialize(that); return(thisSerialized == thatSerialized); }
/// <summary> /// Raises the specified event. /// </summary> /// <param name="evt">The event.</param> /// <exception cref="System.ArgumentNullException">evt</exception> public virtual Task RaiseAsync <T>(Event <T> evt) { if (evt == null) { throw new ArgumentNullException(nameof(evt)); } if (_helper.CanRaiseEvent(evt)) { var json = LogSerializer.Serialize(_helper.PrepareEvent(evt)); _logger.LogInformation(json); } return(Task.FromResult(0)); }
private string CreateLogsContent(IList <Log> logs) { var logContainer = new LogContainer(logs); // Save times foreach (var log in logContainer.Logs) { log.Toffset = TimeHelper.CurrentTimeInMilliseconds() - log.Toffset; } // Serialize request var requestContent = LogSerializer.Serialize(logContainer); return(requestContent); }
internal async Task EnsureConfigurationAsync() { if (_options.Flow == OidcClientOptions.AuthenticationFlow.Hybrid && _options.Policy.RequireIdentityTokenSignature == false) { var error = "Allowing unsigned identity tokens is not allowed for hybrid flow"; _logger.LogError(error); throw new InvalidOperationException(error); } await EnsureProviderInformationAsync(); _logger.LogTrace("Effective options:"); _logger.LogTrace(LogSerializer.Serialize(_options)); }
public async Task RecreateCorruptedDatabaseOnInnerCorruptException() { var mockStorageAdapter = Mock.Of<IStorageAdapter>(); using (var storage = new Microsoft.AppCenter.Storage.Storage(mockStorageAdapter, _databasePath)) { var exception = new StorageCorruptedException("Mock exception"); var testLog = TestLog.CreateTestLog(); var testLogString = LogSerializer.Serialize(testLog); var testLogSize = Encoding.UTF8.GetBytes(testLogString).Length; Mock.Get(mockStorageAdapter).Setup(adapter => adapter.GetMaxStorageSize()).Returns(testLogSize + 1); Mock.Get(mockStorageAdapter).Setup(adapter => adapter.Insert(TableName, It.IsAny<string[]>(), It.IsAny<List<object[]>>())).Throws(exception); await Assert.ThrowsExceptionAsync<StorageCorruptedException>(() => storage.PutLog(StorageTestChannelName, testLog)); Mock.Get(mockStorageAdapter).Verify(adapter => adapter.Dispose()); Mock.Get(mockStorageAdapter).Verify(adapter => adapter.Initialize(It.IsAny<string>()), Times.Exactly(2)); } }
public void ReadErrorLogFile() { var errorLog = new ManagedErrorLog { Id = Guid.NewGuid(), ProcessId = 123 }; var serializedErrorLog = LogSerializer.Serialize(errorLog); var mockFile = Mock.Of <File>(); Mock.Get(mockFile).Setup(file => file.ReadAllText()).Returns(serializedErrorLog); var actualContents = ErrorLogHelper.ReadErrorLogFile(mockFile); Assert.AreEqual(errorLog.Id, actualContents.Id); Assert.AreEqual(errorLog.ProcessId, actualContents.ProcessId); }