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