add failed sync dump which will export the commits, the entity which the update failed on and the error message

Author: hahn-kev

src/SIL.Harmony/CrdtConfig.cs

@@ -72,6 +72,8 @@ private void JsonTypeModifier(JsonTypeInfo typeInfo)
 
     public bool RemoteResourcesEnabled { get; private set; }
     public string LocalResourceCachePath { get; set; } = Path.GetFullPath("./localResourceCache");
+    public string FailedSyncOutputPath { get; set; } = Path.GetFullPath("./failedSyncs");
+
     public void AddRemoteResourceEntity(string? cachePath = null)
     {
         RemoteResourcesEnabled = true;

src/SIL.Harmony/CrdtKernel.cs

@@ -26,7 +26,8 @@ public static IServiceCollection AddCrdtData<TContext>(this IServiceCollection s
             provider.GetRequiredService<CrdtRepository>(),
             provider.GetRequiredService<JsonSerializerOptions>(),
             provider.GetRequiredService<IHybridDateTimeProvider>(),
-            provider.GetRequiredService<IOptions<CrdtConfig>>()
+            provider.GetRequiredService<IOptions<CrdtConfig>>(),
+            provider.GetRequiredService<ILogger<DataModel>>()
         ));
         //must use factory method because ResourceService constructor is internal
         services.AddScoped<ResourceService>(provider => new ResourceService(

src/SIL.Harmony/DataModel.cs

@@ -1,6 +1,7 @@
 using System.Text.Json;
 using SIL.Harmony.Core;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using SIL.Harmony.Changes;
 using SIL.Harmony.Db;
@@ -22,17 +23,20 @@ public class DataModel : ISyncable, IAsyncDisposable
     private readonly JsonSerializerOptions _serializerOptions;
     private readonly IHybridDateTimeProvider _timeProvider;
     private readonly IOptions<CrdtConfig> _crdtConfig;
+    private readonly ILogger<DataModel> _logger;
 
     //constructor must be internal because CrdtRepository is internal
     internal DataModel(CrdtRepository crdtRepository,
         JsonSerializerOptions serializerOptions,
         IHybridDateTimeProvider timeProvider,
-        IOptions<CrdtConfig> crdtConfig)
+        IOptions<CrdtConfig> crdtConfig,
+        ILogger<DataModel> logger)
     {
         _crdtRepository = crdtRepository;
         _serializerOptions = serializerOptions;
         _timeProvider = timeProvider;
         _crdtConfig = crdtConfig;
+        _logger = logger;
     }
 
 
@@ -131,19 +135,48 @@ private static ChangeEntity<IChange> ToChangeEntity(IChange change, int index)
     async Task ISyncable.AddRangeFromSync(IEnumerable<Commit> commits)
     {
         commits = commits.ToArray();
-        _timeProvider.TakeLatestTime(commits.Select(c => c.HybridDateTime));
-        var (oldestChange, newCommits) = await _crdtRepository.FilterExistingCommits(commits.ToArray());
-        //no changes added
-        if (oldestChange is null || newCommits is []) return;
-
-        await using var transaction = await _crdtRepository.BeginTransactionAsync();
-        //if there are deferred commits, update snapshots with them first
-        if (_deferredCommits is not []) await UpdateSnapshotsByDeferredCommits();
-        //don't save since UpdateSnapshots will also modify newCommits with hashes, so changes will be saved once that's done
-        await _crdtRepository.AddCommits(newCommits, false);
-        await UpdateSnapshots(oldestChange, newCommits);
-        await ValidateCommits();
-        await transaction.CommitAsync();
+        try
+        {
+            _timeProvider.TakeLatestTime(commits.Select(c => c.HybridDateTime));
+            var (oldestChange, newCommits) = await _crdtRepository.FilterExistingCommits(commits.ToArray());
+            //no changes added
+            if (oldestChange is null || newCommits is []) return;
+
+            await using var transaction = await _crdtRepository.BeginTransactionAsync();
+            //if there are deferred commits, update snapshots with them first
+            if (_deferredCommits is not []) await UpdateSnapshotsByDeferredCommits();
+            //don't save since UpdateSnapshots will also modify newCommits with hashes, so changes will be saved once that's done
+            await _crdtRepository.AddCommits(newCommits, false);
+            await UpdateSnapshots(oldestChange, newCommits);
+            await ValidateCommits();
+            await transaction.CommitAsync();
+        }
+        catch (DbUpdateException e)
+        {
+            _logger.LogError(e, "Failed to sync commits, check {FailedImportPath} for more details", _crdtConfig.Value.FailedSyncOutputPath);
+            await DumpFailedSync(new
+            {
+                ExceptionMessage = e.ToString(),
+                Commits = commits.DefaultOrder(),
+                Objects = e.Entries.Select(entry => entry.Entity)
+            });
+            throw;
+        }
+    }
+
+    private async Task DumpFailedSync(object data)
+    {
+        try
+        {
+            Directory.CreateDirectory(_crdtConfig.Value.FailedSyncOutputPath);
+            await using var failedImport =
+                File.Create(Path.Combine(_crdtConfig.Value.FailedSyncOutputPath, "last-failed-import.json"));
+            await JsonSerializer.SerializeAsync(failedImport, data, _serializerOptions);
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Failed to dump failed import");
+        }
     }
 
     ValueTask<bool> ISyncable.ShouldSync()