Enable writing events to external database

src/Microsoft.Health.Fhir.SqlServer/Features/Storage/SqlRetry/SqlRetryService.cs

@@ -69,6 +69,7 @@ private readonly HashSet<int> _transientErrors
         private int _commandTimeout;
         private static ReplicaHandler _replicaHandler;
         private static object _initLocker = new object();
+        private static EventLogHandler _eventLogHandler;
 
         /// <summary>
         /// Constructor that initializes this implementation of the ISqlRetryService interface. This class
@@ -109,12 +110,14 @@ public SqlRetryService(
             _customIsExceptionRetriable = sqlRetryServiceDelegateOptions.CustomIsExceptionRetriable;
 
             InitReplicaHandler();
+            InitEventLogHandler();
         }
 
         private SqlRetryService(ISqlConnectionBuilder sqlConnectionBuilder)
         {
             _sqlConnectionBuilder = sqlConnectionBuilder;
             InitReplicaHandler();
+            InitEventLogHandler();
         }
 
         /// <summary>
@@ -371,12 +374,23 @@ public async Task TryLogEvent(string process, string status, string text, DateTi
                     cmd.Parameters.AddWithValue("@Start", startDate.Value);
                 }
 
-                using var conn = await _sqlConnectionBuilder.GetSqlConnectionAsync(initialCatalog: null, cancellationToken: cancellationToken).ConfigureAwait(false);
-                conn.RetryLogicProvider = null;
-                await conn.OpenAsync(cancellationToken);
-                cmd.Connection = conn;
-
-                await cmd.ExecuteNonQueryAsync(cancellationToken);
+                var connStr = _eventLogHandler.GetEventLogConnectionString(_sqlConnectionBuilder);
+                if (connStr == null)
+                {
+                    using var conn = await _sqlConnectionBuilder.GetSqlConnectionAsync(initialCatalog: null, cancellationToken: cancellationToken).ConfigureAwait(false);
+                    conn.RetryLogicProvider = null;
+                    await conn.OpenAsync(cancellationToken);
+                    cmd.Connection = conn;
+                    await cmd.ExecuteNonQueryAsync(cancellationToken);
+                }
+                else
+                {
+                    using var conn = new SqlConnection(connStr);
+                    conn.RetryLogicProvider = null;
+                    await conn.OpenAsync(cancellationToken);
+                    cmd.Connection = conn;
+                    await cmd.ExecuteNonQueryAsync(cancellationToken);
+                }
             }
             catch
             {
@@ -395,10 +409,21 @@ private static void InitReplicaHandler()
             }
         }
 
+        private static void InitEventLogHandler()
+        {
+            if (_eventLogHandler == null) // this is needed, strictly speaking, only if SqlRetryService is not singleton, but it works either way.
+            {
+                lock (_initLocker)
+                {
+                    _eventLogHandler ??= new EventLogHandler();
+                }
+            }
+        }
+
         private class ReplicaHandler
         {
             private DateTime? _lastUpdated;
-            private object _databaseAccessLocker = new object();
+            private readonly object _databaseAccessLocker = new object();
             private double _replicaTrafficRatio = 0;
             private long _usageCounter = 0;
 
@@ -481,5 +506,51 @@ private static double GetReplicaTrafficRatioFromDatabase(ISqlConnectionBuilder s
                 }
             }
         }
+
+        private class EventLogHandler
+        {
+            private bool _initialized = false;
+            private readonly object _databaseAccessLocker = new object();
+            private string _eventLogConnectionString = null;
+
+            public EventLogHandler()
+            {
+            }
+
+            internal string GetEventLogConnectionString(ISqlConnectionBuilder sqlConnectionBuilder)
+            {
+                if (!_initialized)
+                {
+                    lock (_databaseAccessLocker)
+                    {
+                        if (!_initialized)
+                        {
+                            _eventLogConnectionString = GetEventLogConnectionStringFromDatabase(sqlConnectionBuilder);
+                        }
+                    }
+                }
+
+                return _eventLogConnectionString;
+            }
+
+            private string GetEventLogConnectionStringFromDatabase(ISqlConnectionBuilder sqlConnectionBuilder)
+            {
+                try
+                {
+                    using var conn = sqlConnectionBuilder.GetSqlConnection();
+                    conn.RetryLogicProvider = null;
+                    conn.Open();
+                    using var cmd = new SqlCommand("IF object_id('dbo.Parameters') IS NOT NULL SELECT Char FROM dbo.Parameters WHERE Id = 'EventLogConnectionString'", conn);
+                    var value = cmd.ExecuteScalar();
+                    var result = value == null ? null : (string)value;
+                    _initialized = true;
+                    return result;
+                }
+                catch (SqlException)
+                {
+                    return null;
+                }
+            }
+        }
     }
 }