private void Awake()
{
Configuration = GetComponent <BacktraceClient>().Configuration;
if (Configuration == null || !Configuration.IsValid())
{
Debug.LogWarning("Configuration doesn't exists or provided serverurl/token are invalid");
_enable = false;
return;
}
DatabaseSettings = new BacktraceDatabaseSettings(Configuration);
if (DatabaseSettings == null)
{
_enable = false;
return;
}
if (Configuration.CreateDatabase)
{
Directory.CreateDirectory(Configuration.DatabasePath);
}
_enable = Configuration.Enabled && BacktraceConfiguration.ValidateDatabasePath(Configuration.DatabasePath);
if (!_enable)
{
return;
}
_lastConnection = Time.time;
BacktraceDatabaseContext = new BacktraceDatabaseContext(DatabasePath, DatabaseSettings.RetryLimit, DatabaseSettings.RetryOrder);
BacktraceDatabaseFileContext = new BacktraceDatabaseFileContext(DatabasePath, DatabaseSettings.MaxDatabaseSize, DatabaseSettings.MaxRecordCount);
BacktraceApi = new BacktraceApi(Configuration.ToCredentials(), Convert.ToUInt32(Configuration.ReportPerMin));
}
/// <summary>
/// Reload Backtrace database configuration. Reloading configuration is required, when you change
/// BacktraceDatabase configuration options.
/// </summary>
public void Reload()
{
// validate configuration
if (Configuration == null)
{
Configuration = GetComponent <BacktraceClient>().Configuration;
}
if (Configuration == null || !Configuration.IsValid())
{
Debug.LogWarning("Configuration doesn't exists or provided serverurl/token are invalid");
Enable = false;
return;
}
//setup database object
DatabaseSettings = new BacktraceDatabaseSettings(Configuration);
Enable = Configuration.Enabled && BacktraceConfiguration.ValidateDatabasePath(Configuration.DatabasePath);
if (!Enable)
{
Debug.LogWarning("Cannot initialize database - invalid database configuration. Database is disabled");
return;
}
CreateDatabaseDirectory();
SetupMultisceneSupport();
_lastConnection = Time.time;
//Setup database context
BacktraceDatabaseContext = new BacktraceDatabaseContext(DatabasePath, DatabaseSettings.RetryLimit, DatabaseSettings.RetryOrder, DatabaseSettings.DeduplicationStrategy);
BacktraceDatabaseFileContext = new BacktraceDatabaseFileContext(DatabasePath, DatabaseSettings.MaxDatabaseSize, DatabaseSettings.MaxRecordCount);
BacktraceApi = new BacktraceApi(Configuration.ToCredentials());
_reportLimitWatcher = new ReportLimitWatcher(Convert.ToUInt32(Configuration.ReportPerMin));
}
/// <summary>
/// Validate database size - check how many records are stored
/// in database and how much records need space.
/// If space or number of records are invalid
/// database will remove old reports
/// </summary>
private bool ValidateDatabaseSize()
{
//check how many records are stored in database
//remove in case when we want to store one more than expected number
//If record count == 0 then we ignore this condition
var noMoreSpaceForReport = ReachedMaximumNumberOfRecords();
//check database size. If database size == 0 then we ignore this condition
//remove all records till database use enough space
var noMoreSpace = ReachedDiskSpaceLimit();
if (noMoreSpaceForReport || noMoreSpace)
{
//if your database is entry or every record is locked
//deletePolicyRetry avoid infinity loop
int deletePolicyRetry = 5;
while (ReachedDiskSpaceLimit() || ReachedMaximumNumberOfRecords())
{
var lastRecord = BacktraceDatabaseContext.LastOrDefault();
if (lastRecord != null)
{
BacktraceDatabaseContext.Delete(lastRecord);
BacktraceDatabaseFileContext.Delete(lastRecord);
}
deletePolicyRetry--;
if (deletePolicyRetry == 0)
{
break;
}
}
return(deletePolicyRetry != 0);
}
return(true);
}
/// <summary>
/// Load all records stored in database path
/// </summary>
protected virtual void LoadReports()
{
if (!Enable)
{
return;
}
var files = BacktraceDatabaseFileContext.GetRecords();
foreach (var file in files)
{
var record = BacktraceDatabaseRecord.ReadFromFile(file);
if (record == null)
{
continue;
}
record.DatabasePath(DatabaseSettings.DatabasePath);
if (!record.Valid())
{
try
{
Debug.Log("Removing record from Backtrace Database path - invalid record.");
record.Delete();
}
catch (Exception)
{
Debug.LogWarning(string.Format("Cannot remove file from database. File name: {0}", file.FullName));
}
continue;
}
BacktraceDatabaseContext.Add(record);
ValidateDatabaseSize();
record.Unlock();
}
}
/// <summary>
/// Load all records stored in database path
/// </summary>
protected virtual void LoadReports()
{
if (!Enable)
{
return;
}
var files = BacktraceDatabaseFileContext.GetRecords();
foreach (var file in files)
{
var record = BacktraceDatabaseRecord.ReadFromFile(file);
if (record == null)
{
continue;
}
if (!BacktraceDatabaseFileContext.IsValidRecord(record))
{
BacktraceDatabaseFileContext.Delete(record);
continue;
}
BacktraceDatabaseContext.Add(record);
ValidateDatabaseSize();
record.Unlock();
}
}
/// <summary>
/// Delete single record from database
/// </summary>
/// <param name="record">Record to delete</param>
public void Delete(BacktraceDatabaseRecord record)
{
if (BacktraceDatabaseContext != null)
{
BacktraceDatabaseContext.Delete(record);
}
if (BacktraceDatabaseFileContext != null)
{
BacktraceDatabaseFileContext.Delete(record);
}
}
/// <summary>
/// Delete all existing files and directories in current database directory
/// </summary>
public void Clear()
{
if (BacktraceDatabaseContext != null)
{
BacktraceDatabaseContext.Clear();
}
if (BacktraceDatabaseContext != null)
{
BacktraceDatabaseFileContext.Clear();
}
}
private void IncrementBatchRetry()
{
var data = BacktraceDatabaseContext.GetRecordsToDelete();
BacktraceDatabaseContext.IncrementBatchRetry();
if (data != null && data.Count() != 0)
{
foreach (var item in data)
{
BacktraceDatabaseFileContext.Delete(item);
}
}
}
/// <summary>
/// Create Backtrace database instance
/// </summary>
/// <param name="databaseSettings">Backtrace database settings</param>
public BacktraceDatabase(BacktraceDatabaseSettings databaseSettings)
{
if (databaseSettings == null || string.IsNullOrEmpty(databaseSettings.DatabasePath))
{
return;
}
if (!Directory.Exists(databaseSettings.DatabasePath))
{
throw new ArgumentException("Databse path does not exists");
}
DatabaseSettings = databaseSettings;
BacktraceDatabaseContext = new BacktraceDatabaseContext(databaseSettings);
BacktraceDatabaseFileContext = new BacktraceDatabaseFileContext(DatabasePath, DatabaseSettings.MaxDatabaseSize, DatabaseSettings.MaxRecordCount);
}
/// <summary>
/// Load all records stored in database path
/// </summary>
private void LoadReports()
{
var files = BacktraceDatabaseFileContext.GetRecords();
foreach (var file in files)
{
var record = BacktraceDatabaseRecord.ReadFromFile(file);
if (!record.Valid())
{
record.Delete();
continue;
}
BacktraceDatabaseContext.Add(record);
ValidateDatabaseSize();
record.Dispose();
}
}
/// <summary>
/// Reload Backtrace database configuration. Reloading configuration is required, when you change
/// BacktraceDatabase configuration options.
/// </summary>
public void Reload()
{
// validate configuration
if (Configuration == null)
{
Configuration = GetComponent <BacktraceClient>().Configuration;
}
if (Instance != null)
{
return;
}
if (Configuration == null || !Configuration.IsValid())
{
Enable = false;
return;
}
#if UNITY_SWITCH
Enable = false;
#else
Enable = Configuration.Enabled && InitializeDatabasePaths();
#endif
if (!Enable)
{
if (Configuration.Enabled)
{
Debug.LogWarning("Cannot initialize database - invalid path to database. Database is disabled");
}
return;
}
//setup database object
DatabaseSettings = new BacktraceDatabaseSettings(DatabasePath, Configuration);
SetupMultisceneSupport();
_lastConnection = Time.time;
LastFrameTime = Time.time;
//Setup database context
BacktraceDatabaseContext = new BacktraceDatabaseContext(DatabaseSettings);
BacktraceDatabaseFileContext = new BacktraceDatabaseFileContext(DatabaseSettings.DatabasePath, DatabaseSettings.MaxDatabaseSize, DatabaseSettings.MaxRecordCount);
BacktraceApi = new BacktraceApi(Configuration.ToCredentials());
_reportLimitWatcher = new ReportLimitWatcher(Convert.ToUInt32(Configuration.ReportPerMin));
}
/// <summary>
/// Load all records stored in database path
/// </summary>
private void LoadReports()
{
var files = BacktraceDatabaseFileContext.GetRecords();
foreach (var file in files)
{
var record = BacktraceDatabaseRecord.ReadFromFile(file);
if (!record.Valid())
{
try
{
record.Delete();
}
catch (Exception)
{
Debug.LogWarning($"Cannot remove file from database. File name: {file.FullName}");
}
continue;
}
BacktraceDatabaseContext.Add(record);
ValidateDatabaseSize();
record.Dispose();
}
}
/// <summary>
/// Valid database consistency requirements
/// </summary>
public bool ValidConsistency()
{
return(BacktraceDatabaseFileContext.ValidFileConsistency());
}
/// <summary>
/// Detect all orphaned minidump and files
/// </summary>
private void RemoveOrphaned()
{
var records = BacktraceDatabaseContext.Get();
BacktraceDatabaseFileContext.RemoveOrphaned(records);
}
/// <summary>
/// Delete all existing files and directories in current database directory
/// </summary>
public void Clear()
{
BacktraceDatabaseContext?.Clear();
BacktraceDatabaseFileContext?.Clear();
}
/// <summary>
/// Detect all orphaned minidump and files
/// </summary>
protected virtual void RemoveOrphaned()
{
var records = BacktraceDatabaseContext.Get();
BacktraceDatabaseFileContext.RemoveOrphaned(records);
}
/// <summary>
/// Add new report to BacktraceDatabase
/// </summary>
public BacktraceDatabaseRecord Add(BacktraceData data, bool @lock = true)
{
if (data == null || !Enable)
{
return(null);
}
//remove old reports (if database is full)
//and check database health state
var validationResult = ValidateDatabaseSize();
if (!validationResult)
{
return(null);
}
// validate if record already exists in the database object
var hash = BacktraceDatabaseContext.GetHash(data);
if (!string.IsNullOrEmpty(hash))
{
var existingRecord = BacktraceDatabaseContext.GetRecordByHash(hash);
if (existingRecord != null)
{
BacktraceDatabaseContext.AddDuplicate(existingRecord);
return(existingRecord);
}
}
//add built-in attachments
var attachments = BacktraceDatabaseFileContext.GenerateRecordAttachments(data);
for (int attachmentIndex = 0; attachmentIndex < attachments.Count(); attachmentIndex++)
{
if (!string.IsNullOrEmpty(attachments.ElementAt(attachmentIndex)))
{
data.Attachments.Add(attachments.ElementAt(attachmentIndex));
}
}
// add to fresh new record breadcrumb attachment
if (Breadcrumbs != null)
{
data.Attachments.Add(Breadcrumbs.GetBreadcrumbLogPath());
data.Attributes.Attributes["breadcrumbs.lastId"] = Breadcrumbs.BreadcrumbId().ToString("F0", CultureInfo.InvariantCulture);
}
// now we now we're adding new unique report to database
var record = new BacktraceDatabaseRecord(data)
{
Hash = hash
};
// save record on the hard drive and add it to database context
var saveResult = BacktraceDatabaseFileContext.Save(record);
if (!saveResult)
{
// file context won't remove json object that wasn't stored in the previous method
// but will clean up attachments associated with this record.
BacktraceDatabaseFileContext.Delete(record);
return(null);
}
BacktraceDatabaseContext.Add(record);
if (!@lock)
{
record.Unlock();
}
return(record);
}
