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