remove lagging config as per review

Author: Cmdv

cardano-db-sync/src/Cardano/DbSync/Config/Types.hs

@@ -86,6 +86,8 @@ import Ouroboros.Consensus.Protocol.Praos (Praos)
 import Ouroboros.Consensus.Protocol.TPraos (TPraos)
 import Ouroboros.Consensus.Shelley.Ledger.Block (ShelleyBlock)
 
+{- HLINT ignore "Reduce duplication" -}
+
 newtype LogFileDir = LogFileDir
   { unLogFileDir :: FilePath
   }
@@ -282,7 +284,6 @@ data JsonTypeConfig
 
 data SnapshotIntervalConfig = SnapshotIntervalConfig
   { sicNearTipEpoch :: !Word64
-  , sicLagging :: !Word64
   }
   deriving (Eq, Show)
 
@@ -740,20 +741,17 @@ instance ToJSON SnapshotIntervalConfig where
   toJSON cfg =
     Aeson.object
       [ "near_tip_epoch" .= sicNearTipEpoch cfg
-      , "lagging" .= sicLagging cfg
       ]
 
 instance FromJSON SnapshotIntervalConfig where
   parseJSON = Aeson.withObject "snapshot_interval" $ \obj ->
     SnapshotIntervalConfig
       <$> obj .:? "near_tip_epoch" .!= sicNearTipEpoch def
-      <*> obj .:? "lagging" .!= sicLagging def
 
 instance Default SnapshotIntervalConfig where
   def =
     SnapshotIntervalConfig
       { sicNearTipEpoch = 580 -- Epoch threshold to consider being near tip
-      , sicLagging = 100000 -- Every 100,000 blocks when syncing (less frequent)
       }
 
 instance Default SyncInsertConfig where

cardano-db-sync/src/Cardano/DbSync/Ledger/State.hs

@@ -54,7 +54,6 @@ import qualified Cardano.Ledger.BaseTypes as Ledger
 import Cardano.Ledger.Shelley.AdaPots (AdaPots)
 import qualified Cardano.Ledger.Shelley.LedgerState as Shelley
 import Cardano.Prelude hiding (atomically)
-import Cardano.Slotting.Block (BlockNo (..))
 import Cardano.Slotting.EpochInfo (EpochInfo, epochInfoEpoch)
 import Cardano.Slotting.Slot (
   EpochNo (..),
@@ -128,7 +127,7 @@ import qualified Ouroboros.Consensus.Shelley.Ledger.Ledger as Consensus
 import Ouroboros.Consensus.Storage.Serialisation (DecodeDisk (..), EncodeDisk (..))
 import Ouroboros.Network.AnchoredSeq (AnchoredSeq (..))
 import qualified Ouroboros.Network.AnchoredSeq as AS
-import Ouroboros.Network.Block (HeaderHash, Point (..), blockNo)
+import Ouroboros.Network.Block (HeaderHash, Point (..))
 import qualified Ouroboros.Network.Point as Point
 import System.Directory (doesFileExist, listDirectory, removeFile)
 import System.FilePath (dropExtension, takeExtension, (</>))
@@ -187,7 +186,6 @@ mkHasLedgerEnv trce protoInfo dir nw systemStart syncOptions = do
       , leSystemStart = systemStart
       , leAbortOnPanic = soptAbortOnInvalid syncOptions
       , leSnapshotNearTipEpoch = sicNearTipEpoch $ soptSnapshotInterval syncOptions
-      , leSnapshotEveryLagging = sicLagging $ soptSnapshotInterval syncOptions
       , leInterpreter = intervar
       , leStateVar = svar
       , leStateWriteQueue = swQueue
@@ -219,7 +217,7 @@ applyBlockAndSnapshot :: HasLedgerEnv -> CardanoBlock -> Bool -> IO (ApplyResult
 applyBlockAndSnapshot ledgerEnv blk isCons = do
   (oldState, appResult) <- applyBlock ledgerEnv blk
   -- 864000 seconds = 10 days; consider synced "near tip" if within 10 days of current time
-  tookSnapshot <- storeSnapshotAndCleanupMaybe ledgerEnv oldState appResult (blockNo blk) isCons (isSyncedWithinSeconds (apSlotDetails appResult) 864000)
+  tookSnapshot <- storeSnapshotAndCleanupMaybe ledgerEnv oldState appResult isCons (isSyncedWithinSeconds (apSlotDetails appResult) 864000)
   pure (appResult, tookSnapshot)
 
 -- The function 'tickThenReapply' does zero validation, so add minimal validation ('blockPrevHash'
@@ -322,11 +320,10 @@ storeSnapshotAndCleanupMaybe ::
   HasLedgerEnv ->
   CardanoLedgerState ->
   ApplyResult ->
-  BlockNo ->
   Bool ->
   SyncState ->
   IO Bool
-storeSnapshotAndCleanupMaybe env oldState appResult blkNo isCons syncState =
+storeSnapshotAndCleanupMaybe env oldState appResult isCons syncState =
   case maybeFromStrict (apNewEpoch appResult) of
     Just newEpoch
       | newEpochNo <- unEpochNo (Generic.neEpoch newEpoch)
@@ -337,18 +334,7 @@ storeSnapshotAndCleanupMaybe env oldState appResult blkNo isCons syncState =
             -- TODO: Instead of newEpochNo - 1, is there any way to get the epochNo from 'lssOldState'?
             liftIO $ saveCleanupState env oldState (Just $ EpochNo $ newEpochNo - 1)
             pure True
-    _ ->
-      if timeToSnapshot syncState blkNo && isCons
-        then do
-          liftIO $ saveCleanupState env oldState Nothing
-          pure True
-        else pure False
-  where
-    timeToSnapshot :: SyncState -> BlockNo -> Bool
-    timeToSnapshot syncSt bNo =
-      case (syncSt, unBlockNo bNo) of
-        (SyncFollowing, _) -> False -- No block-based snapshots when following
-        (SyncLagging, bno) -> bno `mod` leSnapshotEveryLagging env == 0
+    _ -> pure False
 
 saveCurrentLedgerState :: HasLedgerEnv -> CardanoLedgerState -> Maybe EpochNo -> IO ()
 saveCurrentLedgerState env lState mEpochNo = do

cardano-db-sync/src/Cardano/DbSync/Ledger/Types.hs

@@ -68,7 +68,6 @@ data HasLedgerEnv = HasLedgerEnv
   , leSystemStart :: !SystemStart
   , leAbortOnPanic :: !Bool
   , leSnapshotNearTipEpoch :: !Word64
-  , leSnapshotEveryLagging :: !Word64
   , leInterpreter :: !(StrictTVar IO (Strict.Maybe CardanoInterpreter))
   , leStateVar :: !(StrictTVar IO (Strict.Maybe LedgerDB))
   , leStateWriteQueue :: !(TBQueue (FilePath, CardanoLedgerState))

cardano-db-sync/test/Cardano/DbSync/Gen.hs

@@ -64,7 +64,6 @@ snapshotIntervalConfig :: Gen SnapshotIntervalConfig
 snapshotIntervalConfig =
   SnapshotIntervalConfig
     <$> Gen.word64 (Range.linear 100 1000)
-    <*> Gen.word64 (Range.linear 10000 100000)
 
 syncNodeParams :: MonadGen m => m SyncNodeParams
 syncNodeParams =

doc/configuration.md

@@ -617,7 +617,6 @@ Snapshot Interval Properties:
 | Property                         | Type      | Required | Default |
 | :------------------------------- | :-------- | :------- | :------ |
 | [near\_tip\_epoch](#near-tip-epoch) | `integer` | Optional | 580     |
-| [lagging](#lagging)              | `integer` | Optional | 100000  |
 
 ### Near Tip Epoch
 
@@ -626,33 +625,21 @@ Snapshot Interval Properties:
 * Type: `integer`
 * Default: `580`
 
-Epoch threshold used to determine snapshot behavior. When syncing reaches this epoch or later, db-sync is considered to be approaching or at the current tip of the chain. Combined with time-based detection (within 10 days of current time), this ensures snapshots are taken every epoch when near the tip for fast rollback recovery. During earlier epochs or when syncing behind, snapshots are taken every 10 epochs or according to the `lagging` block interval.
-
-### Lagging
-
-`snapshot_interval.lagging`
-
-* Type: `integer`
-* Default: `100000`
-
-Number of blocks between snapshots when db-sync is syncing and significantly behind the tip of the chain (more than 10 days behind current time). Less frequent snapshots during initial sync improves performance by reducing expensive disk operations.
+Epoch threshold used to determine snapshot behavior. When syncing reaches this epoch or later, db-sync is considered to be approaching or at the current tip of the chain. Combined with time-based detection (within 10 days of current time), this ensures snapshots are taken every epoch when near the tip for fast rollback recovery. During earlier epochs or when syncing behind, snapshots are taken every 10 epochs.
 
 ### Example
 
 ```json
 {
   "snapshot_interval": {
-    "near_tip_epoch": 580,
-    "lagging": 100000
+    "near_tip_epoch": 580
   }
 }
 ```
 
 ### Performance Considerations
 
 - **Lower `near_tip_epoch` value**: Start taking frequent epoch-based snapshots earlier in the chain history
-- **Higher `near_tip_epoch` value**: Delay frequent snapshots until later in the chain, improving sync speed for longer
-- **Larger `lagging` value**: Faster initial sync with reduced IOPS, but slower recovery if rollback is needed during sync
-- **Recommended for initial sync**: Use a large `lagging` value (100000+) and appropriate `near_tip_epoch` to maximize sync speed
+- **Higher `near_tip_epoch` value**: Delay frequent snapshots until later in the chain, improving sync speed for longer. During initial sync (before reaching `near_tip_epoch`), snapshots are taken every 10 epochs
 - **Near tip detection**: Automatically switches to epoch-based snapshots when within 10 days of current time, regardless of epoch number