pool test

src/Microsoft.Health.Fhir.Api/Features/BackgroundJobService/HostingBackgroundService.cs

@@ -61,7 +61,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
                 JobHosting jobHostingValue = jobHosting.Value;
                 if (_hostingConfiguration != null)
                 {
-                    jobHostingValue.PollingFrequencyInSeconds = _hostingConfiguration.PollingFrequencyInSeconds ?? jobHostingValue.PollingFrequencyInSeconds;
+                    jobHostingValue.PollingFrequencyInSeconds = 1; ////_hostingConfiguration.PollingFrequencyInSeconds ?? jobHostingValue.PollingFrequencyInSeconds;
                     jobHostingValue.JobHeartbeatIntervalInSeconds = _hostingConfiguration.TaskHeartbeatIntervalInSeconds ?? jobHostingValue.JobHeartbeatIntervalInSeconds;
                     jobHostingValue.JobHeartbeatTimeoutThresholdInSeconds = _hostingConfiguration.TaskHeartbeatTimeoutThresholdInSeconds ?? jobHostingValue.JobHeartbeatTimeoutThresholdInSeconds;
                 }

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

@@ -7,6 +7,8 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Diagnostics;
+using System.Globalization;
+using System.Security.Cryptography;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -410,7 +412,7 @@ private class ReplicaHandler
             private readonly object _databaseAccessLocker = new object();
             private double _replicaTrafficRatio = 0;
 
-            private long _usageCounter = 0;
+            ////private long _usageCounter = 0;
             private CoreFeatureConfiguration _coreFeatureConfiguration;
 
             public ReplicaHandler(CoreFeatureConfiguration coreFeatureConfiguration)
@@ -425,35 +427,11 @@ public async Task<SqlConnection> GetConnection(ISqlConnectionBuilder sqlConnecti
                 var logSB = new StringBuilder("Long running retrieve SQL connection. ");
                 string isReadOnlyConnection;
 
-                if (!isReadOnly || !_coreFeatureConfiguration.SupportsSqlReplicas)
-                {
-                    logSB.AppendLine("Not read only. ");
-                    isReadOnlyConnection = string.Empty;
-                    conn = await sqlConnectionBuilder.GetSqlConnectionAsync(false, applicationName);
-                }
-                else
-                {
-                    logSB.AppendLine("Checking read only. ");
-                    var replicaTrafficRatio = GetReplicaTrafficRatio(sqlConnectionBuilder, logger);
-                    logSB.AppendLine($"Got replica traffic ratio in {sw.Elapsed.TotalSeconds} seconds. Ratio is {replicaTrafficRatio}. ");
-
-                    if (replicaTrafficRatio < 0.5) // it does not make sense to use replica less than master at all
-                    {
-                        isReadOnlyConnection = string.Empty;
-                        conn = await sqlConnectionBuilder.GetSqlConnectionAsync(false, applicationName);
-                    }
-                    else if (replicaTrafficRatio > 0.99)
-                    {
-                        isReadOnlyConnection = "read-only ";
-                        conn = await sqlConnectionBuilder.GetSqlConnectionAsync(true, applicationName);
-                    }
-                    else
-                    {
-                        var useWriteConnection = unchecked(Interlocked.Increment(ref _usageCounter)) % (int)(1 / (1 - _replicaTrafficRatio)) == 1; // examples for ratio -> % divider = { 0.9 -> 10, 0.8 -> 5, 0.75 - 4, 0.67 - 3, 0.5 -> 2, <0.5 -> 1}
-                        isReadOnlyConnection = useWriteConnection ? string.Empty : "read-only ";
-                        conn = await sqlConnectionBuilder.GetSqlConnectionAsync(!useWriteConnection, applicationName);
-                    }
-                }
+                var numberOfpools = (int)GetReplicaTrafficRatio(sqlConnectionBuilder, logger);
+                applicationName = RandomNumberGenerator.GetInt32(numberOfpools).ToString();
+                logSB.AppendLine("Not read only. ");
+                isReadOnlyConnection = string.Empty;
+                conn = await sqlConnectionBuilder.GetSqlConnectionAsync(false, applicationName);
 
                 // Connection is never opened by the _sqlConnectionBuilder but RetryLogicProvider is set to the old, deprecated retry implementation. According to the .NET spec, RetryLogicProvider
                 // must be set before opening connection to take effect. Therefore we must reset it to null here before opening the connection.
@@ -479,7 +457,7 @@ public async Task<SqlConnection> GetConnection(ISqlConnectionBuilder sqlConnecti
 
             private double GetReplicaTrafficRatio(ISqlConnectionBuilder sqlConnectionBuilder, ILogger logger)
             {
-                const int trafficRatioCacheDurationSec = 600;
+                const int trafficRatioCacheDurationSec = 60;
                 if (_lastUpdated.HasValue && (DateTime.UtcNow - _lastUpdated.Value).TotalSeconds < trafficRatioCacheDurationSec)
                 {
                     return _replicaTrafficRatio;
@@ -521,7 +499,7 @@ private static double GetReplicaTrafficRatioFromDatabase(ISqlConnectionBuilder s
                     conn.Open();
                     using var cmd = new SqlCommand("IF object_id('dbo.Parameters') IS NOT NULL SELECT Number FROM dbo.Parameters WHERE Id = 'ReplicaTrafficRatio'", conn);
                     var value = cmd.ExecuteScalar();
-                    return value == null ? 0 : (double)value;
+                    return value == null ? 1 : (double)value;
                 }
                 catch (SqlException ex)
                 {

src/Microsoft.Health.Fhir.SqlServer/Features/Watchdogs/CleanupEventLogWatchdog.cs

@@ -50,7 +50,7 @@ protected override async Task RunWorkAsync(CancellationToken cancellationToken)
         {
             await using var cmd = new SqlCommand("dbo.CleanupEventLog") { CommandType = CommandType.StoredProcedure, CommandTimeout = 0 };
             await cmd.ExecuteNonQueryAsync(_sqlRetryService, _logger, cancellationToken);
-            await LogSearchParamStats(cancellationToken);
+            ////await LogSearchParamStats(cancellationToken);
         }
 
         protected override async Task InitAdditionalParamsAsync()

src/Microsoft.Health.Fhir.SqlServer/Features/Watchdogs/GeoReplicationLagWatchdog.cs

@@ -71,7 +71,7 @@ internal GeoReplicationLagWatchdog()
         protected override async Task RunWorkAsync(CancellationToken cancellationToken)
         {
             // Check if the current schema version supports the GetGeoReplicationLag stored procedure
-            if (_schemaInformation.Current < MinRequiredSchemaVersion)
+            if (_schemaInformation.Current > 0)
             {
                 _logger.LogDebug(
                     "GeoReplicationLagWatchdog: Current schema version {CurrentVersion} is below minimum required version {MinRequiredVersion}. Skipping execution.",

src/Microsoft.Health.Fhir.SqlServer/Features/Watchdogs/InvisibleHistoryCleanupWatchdog.cs

@@ -12,6 +12,7 @@
 using Microsoft.Data.SqlClient;
 using Microsoft.Extensions.Logging;
 using Microsoft.Health.Fhir.SqlServer.Features.Storage;
+using Microsoft.Health.SqlServer.Features.Schema;
 
 namespace Microsoft.Health.Fhir.SqlServer.Features.Watchdogs
 {
@@ -48,6 +49,11 @@ internal InvisibleHistoryCleanupWatchdog()
 
         protected override async Task RunWorkAsync(CancellationToken cancellationToken)
         {
+            if (RetentionPeriodDays > 0)
+            {
+                return;
+            }
+
             _logger.LogInformation($"{Name}: starting...");
             var visibility = await _store.MergeResourcesGetTransactionVisibilityAsync(cancellationToken);
             _logger.LogInformation($"{Name}: visibility={visibility}.");

src/Microsoft.Health.Fhir.SqlServer/Features/Watchdogs/TransactionWatchdog.cs

@@ -49,7 +49,7 @@ protected override async Task RunWorkAsync(CancellationToken cancellationToken)
 
             _logger.Log(affectedRows > 0 ? LogLevel.Information : LogLevel.Debug, AdvancedVisibilityTemplate, affectedRows);
 
-            if (affectedRows > 0)
+            if (affectedRows >= 0)
             {
                 return;
             }