You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by be...@apache.org on 2025/03/21 23:27:11 UTC

(cassandra-analytics) branch trunk updated: CASSANALYTICS-7: Add Apache Cassandra Sidecar CDC implementation (#99)

This is an automated email from the ASF dual-hosted git repository.

bernardobotella pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/cassandra-analytics.git


The following commit(s) were added to refs/heads/trunk by this push:
     new 75d97e4b CASSANALYTICS-7: Add Apache Cassandra Sidecar CDC implementation (#99)
75d97e4b is described below

commit 75d97e4b5bd8ed0be6f9485c64db734859657f54
Author: jberragan <jb...@gmail.com>
AuthorDate: Fri Mar 21 16:27:07 2025 -0700

    CASSANALYTICS-7: Add Apache Cassandra Sidecar CDC implementation (#99)
    
    Patch by James Berragan; Reviewed by Yifan Cai, Bernardo Botella for CASSANALYTICS-7
---
 CHANGES.txt                                        |   1 +
 cassandra-analytics-cdc-sidecar/build.gradle       | 129 ++++++
 .../cassandra/cdc/CassandraClientSource.java       | 170 ++++++++
 .../cdc/sidecar/ClusterConfigProvider.java         |  37 +-
 .../cdc/sidecar/ReplicationFactorSupplier.java     |  55 +++
 .../apache/cassandra/cdc/sidecar/SidecarCdc.java   |  64 +++
 .../cassandra/cdc/sidecar/SidecarCdcBuilder.java   | 175 +++++++++
 .../cdc/sidecar/SidecarCdcCassandraClient.java     |  72 ++++
 .../cassandra/cdc/sidecar/SidecarCdcClient.java    | 153 ++++++++
 .../cdc/sidecar/SidecarCdcCommitLogSegment.java    | 157 ++++++++
 .../cassandra/cdc/sidecar/SidecarCdcOptions.java   | 168 ++++++++
 .../cassandra/cdc/sidecar/SidecarCdcStats.java     | 277 +++++++++++++
 .../cdc/sidecar/SidecarCommitLogProvider.java      | 143 +++++++
 .../cassandra/cdc/sidecar/SidecarDownMonitor.java  |  68 ++++
 .../cdc/sidecar/SidecarStatePersister.java         | 434 +++++++++++++++++++++
 .../cassandra/cdc/CassandraClientSourceTest.java   | 112 ++++++
 .../cdc/sidecar/SidecarCommitLogProviderTests.java | 196 ++++++++++
 .../cdc/sidecar/SidecarStatePersisterTest.java     | 118 ++++++
 .../main/java/org/apache/cassandra/cdc/Cdc.java    |  12 +-
 .../java/org/apache/cassandra/cdc/CdcBuilder.java  |  18 +-
 .../org/apache/cassandra/cdc/CdcKryoRegister.java  |   2 +-
 .../java/org/apache/cassandra/cdc/TypeCache.java   | 117 ++++++
 .../apache/cassandra/cdc/msg/jdk/CdcMessage.java   |  22 +-
 .../java/org/apache/cassandra/cdc/CdcTester.java   |   2 +-
 .../java/org/apache/cassandra/cdc/CdcTests.java    |   4 +-
 .../org/apache/cassandra/cdc/TypeCacheTests.java   |  85 ++++
 .../org/apache/cassandra/cdc/api/CommitLog.java    |   8 +-
 .../apache/cassandra/cdc/api/CommitLogMarkers.java |   2 +-
 .../apache/cassandra/cdc/api/KeyspaceTypeKey.java  |  69 ++++
 .../cassandra/spark/utils/AsyncExecutor.java       |  47 +++
 cassandra-analytics-core/build.gradle              |   1 +
 .../cassandra/clients/AnalyticsSidecarClient.java  |  87 +++++
 .../spark/bulkwriter/CassandraContext.java         |   4 +-
 ...tion.java => BulkWriterKeyStoreValidation.java} |  28 +-
 ...on.java => BulkWriterTrustStoreValidation.java} |  28 +-
 .../cassandra/clients/SidecarClientConfigTest.java |   4 +-
 cassandra-analytics-sidecar-client/build.gradle    |  65 +++
 .../apache/cassandra/clients/ExecutorHolder.java   |   0
 .../java/org/apache/cassandra/clients/Sidecar.java |  48 ---
 .../clients/SidecarStreamConsumerAdapter.java      |   0
 .../spark/validation/KeyStoreValidation.java       |  24 +-
 .../spark/validation/StartupValidation.java        |   0
 .../spark/validation/StartupValidator.java         |   0
 .../spark/validation/TrustStoreValidation.java     |  24 +-
 gradle.properties                                  |   1 +
 settings.gradle                                    |   2 +
 46 files changed, 3078 insertions(+), 155 deletions(-)

diff --git a/CHANGES.txt b/CHANGES.txt
index f413bb00..f29ef75d 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,4 +1,5 @@
 1.0.0
+ * Add Apache Cassandra Sidecar CDC implementation (CASSANALYTICS-7)
  * Upgrade sidecar client dependency to 0.1.0 (CASSANALYTICS-16)
  * Remove JDK8 support (CASSANALYTICS-17)
  * Support CQL duration type (CASSANALYTICS-18)
diff --git a/cassandra-analytics-cdc-sidecar/build.gradle b/cassandra-analytics-cdc-sidecar/build.gradle
new file mode 100644
index 00000000..914fb34c
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/build.gradle
@@ -0,0 +1,129 @@
+import java.nio.file.Paths
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+plugins {
+    id('java-library')
+    id('maven-publish')
+}
+
+configurations {
+    all*.exclude(group: 'org.slf4j', module: 'slf4j-log4j12')
+    all*.exclude(group: 'log4j', module: 'log4j')
+}
+
+java {
+    withJavadocJar()
+    withSourcesJar()
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from components.java
+            groupId project.group
+            artifactId "${archivesBaseName}"
+            version System.getenv("CODE_VERSION") ?: "${version}"
+        }
+    }
+}
+
+configurations {
+    fourzero {
+        description = 'Cassandra 4.0 dependency'
+    }
+    fourzerobridge {
+        description = 'Bridge to Cassandra 4.0'
+    }
+    fourzerotypes {
+        description = 'Cassandra 4.0 Data Types'
+    }
+}
+
+dependencies {
+    api(project(':cassandra-bridge'))
+
+    fourzero(project(path: ':cassandra-four-zero', configuration: 'shadow'))
+    fourzerobridge(project(path: ':cassandra-four-zero-bridge'))
+    fourzerotypes(project(path: ':cassandra-four-zero-types'))
+
+    implementation project(":cassandra-analytics-common")
+    implementation project(':cassandra-analytics-cdc')
+    implementation project(':cassandra-analytics-sidecar-client')
+    compileOnlyApi("com.datastax.cassandra:cassandra-driver-core:${project.cassandraDriverVersion}") // Cassandra driver is required only if user supplies the CassandraClientSource
+
+    implementation "com.google.guava:guava:${project.guavaVersion}"
+
+    implementation "org.apache.commons:commons-lang3:${project.commonsLang3Version}"
+    implementation "org.slf4j:slf4j-api:${slf4jApiVersion}"
+    implementation "com.esotericsoftware:kryo-shaded:${kryoVersion}"
+    implementation "com.fasterxml.jackson.core:jackson-annotations:${jacksonVersion}"
+    implementation "com.fasterxml.jackson.core:jackson-core:${jacksonVersion}"
+    implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
+
+    testImplementation project(":cassandra-analytics-common")
+
+    // pull in cassandra-bridge so we can re-use TestSchema to generate arbitrary schemas for the cdc tests
+    testImplementation project(":cassandra-bridge")
+    testImplementation("com.datastax.cassandra:cassandra-driver-core:${project.cassandraDriverVersion}")
+    testImplementation(testFixtures(project(':cassandra-bridge')))
+    testImplementation project(":cassandra-four-zero-bridge")
+    testImplementation project(":cassandra-four-zero-types")
+    testImplementation project(path: ':cassandra-four-zero', configuration: 'shadow')
+    testImplementation(group: 'org.quicktheories', name: 'quicktheories', version: "${project.rootProject.quickTheoriesVersion}")
+    testImplementation(group: 'com.google.guava', name: 'guava', version: '31.1-jre')
+    testImplementation(group: 'com.github.luben', name: 'zstd-jni', version: '1.5.0-4')
+    testImplementation(group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.26')
+    testImplementation "org.quicktheories:quicktheories:${project.rootProject.quickTheoriesVersion}"
+    testImplementation "org.junit.jupiter:junit-jupiter-api:${project.junitVersion}"
+    testImplementation "org.junit.jupiter:junit-jupiter-params:${project.junitVersion}"
+    testImplementation "org.junit.jupiter:junit-jupiter-engine:${project.junitVersion}"
+    testImplementation "org.mockito:mockito-core:${project.rootProject.mockitoVersion}"
+    testImplementation "org.mockito:mockito-inline:${project.rootProject.mockitoVersion}"
+}
+
+jar {
+    dependsOn(configurations.fourzero)
+    dependsOn(configurations.fourzerobridge)
+    dependsOn(configurations.fourzerotypes)
+
+    exclude('META-INF/*')
+    into('bridges') {
+        from(configurations.fourzero.singleFile)
+        from(configurations.fourzerobridge.singleFile)
+        from(configurations.fourzerotypes.singleFile)
+    }
+}
+
+test {
+    useJUnitPlatform()
+    reports {
+        def destDir = Paths.get(rootProject.rootDir.absolutePath, "build", "test-reports", "cdc-sidecar").toFile()
+        junitXml {
+            enabled true
+            destination = destDir
+        }
+        html {
+            enabled true
+            destination = destDir
+        }
+    }
+}
+
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/CassandraClientSource.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/CassandraClientSource.java
new file mode 100644
index 00000000..7a7e8b90
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/CassandraClientSource.java
@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.datastax.driver.core.AuthProvider;
+import com.datastax.driver.core.Authenticator;
+import com.datastax.driver.core.BoundStatement;
+import com.datastax.driver.core.PreparedStatement;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.Session;
+import com.datastax.driver.core.exceptions.AuthenticationException;
+import org.apache.cassandra.cdc.api.CassandraSource;
+import org.apache.cassandra.cdc.msg.Value;
+import org.apache.cassandra.spark.data.CassandraTypes;
+
+/**
+ * Optional `CassandraSource` implementation that reads values from the Cassandra cluster using the standard Cassandra client.
+ * This is only used for reading unfrozen lists. In Cassandra, unfrozen lists store the list index as a timeuuid
+ * which is unintelligible for downstream CDC consumers.
+ */
+public class CassandraClientSource implements CassandraSource
+{
+    private static final Logger LOGGER = LoggerFactory.getLogger(CassandraClientSource.class);
+    private static final String READ_QUERY_FORMAT = "SELECT %s from %s.%s where %s";
+    private static final int EXPIRE_AFTER_MINUTES = 60;
+    private final Session session;
+    private final CassandraTypes types;
+    private final Cache<String, PreparedStatement> preparedStatementCache;
+
+    public CassandraClientSource(Session session, CassandraTypes types)
+    {
+        this(session, types, EXPIRE_AFTER_MINUTES);
+    }
+
+    public CassandraClientSource(Session session, CassandraTypes types, int preparedStatementCacheExpireAfterMinutes)
+    {
+        this.session = session;
+        this.types = types;
+        this.preparedStatementCache = CacheBuilder
+                                      .newBuilder()
+                                      .expireAfterAccess(preparedStatementCacheExpireAfterMinutes, TimeUnit.MINUTES)
+                                      .build();
+    }
+
+    @Override
+    public List<ByteBuffer> readFromCassandra(String keyspace, String table,
+                                              List<String> columnsToFetch,
+                                              List<Value> primaryKeyColumns)
+    {
+        // Create the read query & prepare statement
+        List<String> primaryKeyColumnNames = getPrimaryKeyColumnNames(primaryKeyColumns);
+        String readQuery = getReadQuery(keyspace, table, columnsToFetch, primaryKeyColumnNames);
+        PreparedStatement preparedStatement;
+        try
+        {
+            preparedStatement = preparedStatementCache.get(readQuery, () -> session.prepare(readQuery));
+        }
+        catch (ExecutionException e)
+        {
+            LOGGER.error("Unable to load prepared statement for query {}", readQuery, e);
+            preparedStatement = session.prepare(readQuery);
+        }
+
+        // Get primaryKey values & execute query
+        BoundStatement boundStatement = preparedStatement.bind(getPrimaryKeyObjects(types, primaryKeyColumns));
+        ResultSet resultSet = session.execute(boundStatement);
+        if (resultSet.isExhausted())
+        {
+            LOGGER.error("The read query {} to C* failed", readQuery);
+            return null;
+        }
+        Row row = resultSet.one(); // There should only be one row
+
+        // Create list of ByteBuffer with values of columns to fetch
+        List<ByteBuffer> result = new ArrayList<>();
+        for (String column : columnsToFetch)
+        {
+            result.add(row.getBytesUnsafe(column));
+        }
+        return result;
+    }
+
+    @VisibleForTesting
+    static String getReadQuery(String keyspace,
+                               String table,
+                               List<String> columnsToFetch,
+                               List<String> primaryKeyColumns)
+    {
+        String columnsToSelect = StringUtils.join(columnsToFetch, ",");
+        String primaryKeyCondition = primaryKeyColumns.stream()
+                                                      .map(primaryKeyColumn -> primaryKeyColumn + " = ?")
+                                                      .collect(Collectors.joining(" , "));
+        return String.format(READ_QUERY_FORMAT, columnsToSelect, keyspace, table, primaryKeyCondition);
+    }
+
+    @VisibleForTesting
+    static Object[] getPrimaryKeyObjects(CassandraTypes types, List<Value> primaryKeyColumns)
+    {
+        return primaryKeyColumns.stream()
+                                .map(valueWithMetadata -> types.parseType(valueWithMetadata.columnType).deserializeToJavaType(valueWithMetadata.getValue()))
+                                .toArray();
+    }
+
+    private static List<String> getPrimaryKeyColumnNames(List<Value> primaryKeyColumns)
+    {
+        return primaryKeyColumns.stream()
+                                .map(valueWithMetadata -> valueWithMetadata.columnName)
+                                .collect(Collectors.toList());
+    }
+
+    private static class MtlsAuthProvider implements AuthProvider
+    {
+        @Override
+        public Authenticator newAuthenticator(InetSocketAddress inetSocketAddress, String s) throws AuthenticationException
+        {
+            return new MutualTLSAuthenticator();
+        }
+
+        private static class MutualTLSAuthenticator implements Authenticator
+        {
+            public byte[] initialResponse()
+            {
+                return new byte[]{0, 0};
+            }
+
+            public byte[] evaluateChallenge(byte[] bytes)
+            {
+                return null;
+            }
+
+            public void onAuthenticationSuccess(byte[] bytes)
+            {
+                LOGGER.info("Successfully authenticated with mTLS");
+            }
+        }
+    }
+}
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ClusterConfigProvider.java
similarity index 50%
copy from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
copy to cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ClusterConfigProvider.java
index dbb4df15..8584198d 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ClusterConfigProvider.java
@@ -17,26 +17,33 @@
  * under the License.
  */
 
-package org.apache.cassandra.clients;
+package org.apache.cassandra.cdc.sidecar;
 
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
+import java.util.Set;
 
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.data.partitioner.Partitioner;
 
 /**
- * A class that holds Executors used during the Cassandra Analytics execution
+ * Interface to supply cluster topology information for CDC:
+ * the Cassandra partitioner,
+ * the datacenter where CDC is enabled,
+ * CassandraInstance objects describing the cluster topology.
  */
-public final class ExecutorHolder
+public interface ClusterConfigProvider
 {
-    // TODO: Make the size configurable
-    public static final ExecutorService EXECUTOR_SERVICE = Executors.newFixedThreadPool(64,
-            new ThreadFactoryBuilder().setNameFormat("cassandra-analytics-%d")
-                                      .setDaemon(true)
-                                      .build());
+    /**
+     * @return the datacenter name where CDC is enabled.
+     */
+    String dc();
 
-    private ExecutorHolder()
-    {
-        throw new IllegalStateException(getClass() + " is static utility class and shall not be instantiated");
-    }
+    /**
+     * @return set of CassandraInstance objects describing the entire ring topology, including other datacenters.
+     */
+    Set<CassandraInstance> getCluster();
+
+    /**
+     * @return the Cassandra partitioner configured on the cluster.
+     */
+    Partitioner partitioner();
 }
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ReplicationFactorSupplier.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ReplicationFactorSupplier.java
new file mode 100644
index 00000000..f6616efc
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ReplicationFactorSupplier.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import com.google.common.collect.ImmutableMap;
+
+import org.apache.cassandra.spark.data.ReplicationFactor;
+
+public interface ReplicationFactorSupplier
+{
+    ReplicationFactorSupplier DEFAULT = new ReplicationFactorSupplier()
+    {
+        @Override
+        public ReplicationFactor getReplicationFactor(String keyspace)
+        {
+            return new ReplicationFactor(ImmutableMap.of(
+            "class", "SimpleStrategy",
+            "replication_factor", "1"));
+        }
+
+        @Override
+        public ReplicationFactor getMaximalReplicationFactor()
+        {
+            return getReplicationFactor("keyspace");
+        }
+    };
+
+    /**
+     * @param keyspace Cassandra keyspace name
+     * @return ReplicationFactor object for provided keyspace
+     */
+    ReplicationFactor getReplicationFactor(String keyspace);
+
+    /**
+     * @return the maximum replication factor across all CDC keyspaces
+     */
+    ReplicationFactor getMaximalReplicationFactor();
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdc.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdc.java
new file mode 100644
index 00000000..6a652f39
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdc.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.Set;
+
+import org.apache.cassandra.cdc.Cdc;
+import org.apache.cassandra.spark.data.CqlTable;
+import org.apache.cassandra.spark.data.ReplicationFactor;
+import org.apache.cassandra.spark.utils.FutureUtils;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * SidecarCdc implementation that uses the Sidecar HTTP APIs to list and stream commit log segments.
+ */
+public class SidecarCdc extends Cdc
+{
+    protected final ClusterConfigProvider clusterConfigProvider;
+
+    protected SidecarCdc(@NotNull SidecarCdcBuilder builder)
+    {
+        super(builder);
+        this.clusterConfigProvider = builder.clusterConfigProvider;
+        initSchema();
+    }
+
+    public void initSchema()
+    {
+        Set<CqlTable> tables = FutureUtils.get(schemaSupplier.getCdcEnabledTables());
+        Optional<ReplicationFactor> rfOp = tables.stream()
+                                                 .map(CqlTable::replicationFactor)
+                                                 .filter(rf -> rf.getOptions().containsKey(dc()))
+                                                 .max(Comparator.comparingInt(rf -> rf.getOptions().get(dc())));
+
+        if (!rfOp.isPresent())
+        {
+            throw new RuntimeException("Could not find replication factor for any keyspace");
+        }
+    }
+
+    public String dc()
+    {
+        return clusterConfigProvider.dc();
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcBuilder.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcBuilder.java
new file mode 100644
index 00000000..b64d1871
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcBuilder.java
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.io.IOException;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.cassandra.cdc.CdcBuilder;
+import org.apache.cassandra.cdc.api.CdcOptions;
+import org.apache.cassandra.cdc.api.EventConsumer;
+import org.apache.cassandra.cdc.api.SchemaSupplier;
+import org.apache.cassandra.cdc.api.TokenRangeSupplier;
+import org.apache.cassandra.cdc.stats.ICdcStats;
+import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.secrets.SecretsProvider;
+import org.apache.cassandra.sidecar.client.SidecarClient;
+import org.apache.cassandra.sidecar.client.SidecarInstancesProvider;
+import org.apache.cassandra.spark.utils.AsyncExecutor;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("unused")
+public class SidecarCdcBuilder extends CdcBuilder
+{
+    protected ClusterConfigProvider clusterConfigProvider;
+    protected SidecarCdcClient sidecarCdcClient;
+    protected SidecarDownMonitor downMonitor = SidecarDownMonitor.STUB;
+    protected ReplicationFactorSupplier replicationFactorSupplier = ReplicationFactorSupplier.DEFAULT;
+    protected SidecarCdcStats sidecarCdcStats = SidecarCdcStats.STUB;
+    protected SidecarCdcCassandraClient cassandraClient = SidecarCdcCassandraClient.STUB;
+    protected SidecarCdcOptions sidecarCdcOptions = SidecarCdcOptions.DEFAULT;
+
+    SidecarCdcBuilder(@NotNull String jobId,
+                      int partitionId,
+                      CdcOptions cdcOptions,
+                      ClusterConfigProvider clusterConfigProvider,
+                      EventConsumer eventConsumer,
+                      SchemaSupplier schemaSupplier,
+                      TokenRangeSupplier tokenRangeSupplier,
+                      SidecarInstancesProvider sidecarInstancesProvider,
+                      Sidecar.ClientConfig clientConfig,
+                      SecretsProvider secretsProvider,
+                      ICdcStats cdcStats) throws IOException
+    {
+        this(
+        jobId,
+        partitionId,
+        cdcOptions,
+        clusterConfigProvider,
+        eventConsumer,
+        schemaSupplier,
+        tokenRangeSupplier,
+        clientConfig,
+        Sidecar.from(sidecarInstancesProvider, clientConfig, secretsProvider),
+        cdcStats
+        );
+    }
+
+    SidecarCdcBuilder(@NotNull String jobId,
+                      int partitionId,
+                      CdcOptions cdcOptions,
+                      ClusterConfigProvider clusterConfigProvider,
+                      EventConsumer eventConsumer,
+                      SchemaSupplier schemaSupplier,
+                      TokenRangeSupplier tokenRangeSupplier,
+                      Sidecar.ClientConfig clientConfig,
+                      SidecarClient sidecarClient,
+                      ICdcStats cdcStats)
+    {
+        super(jobId, partitionId, eventConsumer, schemaSupplier);
+        this.clusterConfigProvider = clusterConfigProvider;
+        this.sidecarCdcClient = new SidecarCdcClient(clientConfig, sidecarClient, cdcStats);
+        withCdcOptions(cdcOptions);
+        withTokenRangeSupplier(tokenRangeSupplier);
+    }
+
+    public SidecarCdcBuilder withClusterConfigProvider(ClusterConfigProvider clusterConfigProvider)
+    {
+        this.clusterConfigProvider = clusterConfigProvider;
+        return this;
+    }
+
+    public SidecarCdcBuilder withDownMonitor(SidecarDownMonitor downMonitor)
+    {
+        this.downMonitor = downMonitor;
+        return this;
+    }
+
+    public SidecarCdcBuilder withSidecarClient(Sidecar.ClientConfig clientConfig,
+                                               SidecarClient sidecarClient,
+                                               ICdcStats cdcStats)
+    {
+        this.sidecarCdcClient = new SidecarCdcClient(clientConfig, sidecarClient, cdcStats);
+        return this;
+    }
+
+    public SidecarCdcBuilder withReplicationFactorSupplier(ReplicationFactorSupplier replicationFactorSupplier)
+    {
+        this.replicationFactorSupplier = replicationFactorSupplier;
+        return this;
+    }
+
+    @Override
+    public CdcBuilder withCdcOptions(@NotNull CdcOptions cdcOptions)
+    {
+        super.withCdcOptions(cdcOptions);
+        return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new cdcOptions
+    }
+
+    public SidecarCdcBuilder withSidecarCdcStats(SidecarCdcStats sidecarCdcStats)
+    {
+        this.sidecarCdcStats = sidecarCdcStats;
+        return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new SidecarCdcStats
+    }
+
+    public SidecarCdcBuilder withSidecarCdcOptions(SidecarCdcOptions sidecarCdcOptions)
+    {
+        this.sidecarCdcOptions = sidecarCdcOptions;
+        return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new SidecarCdcOptions
+    }
+
+    @Override
+    public SidecarCdcBuilder withExecutor(AsyncExecutor asyncExecutor)
+    {
+        super.withExecutor(asyncExecutor);
+        return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new AsyncExecutor
+    }
+
+    public SidecarCdcBuilder withSidecarCdcCassandraClient(SidecarCdcCassandraClient cassandraClient)
+    {
+        this.cassandraClient = cassandraClient;
+        return withSidecarStatePersister(new SidecarStatePersister(sidecarCdcOptions, cdcOptions, sidecarCdcStats, cassandraClient, asyncExecutor));
+    }
+
+    public SidecarCdcBuilder withSidecarStatePersister(SidecarStatePersister statePersister)
+    {
+        withStatePersister(statePersister);
+        return this;
+    }
+
+    @Override
+    public SidecarCdc build()
+    {
+        Preconditions.checkNotNull(clusterConfigProvider, "A ClusterConfigProvider must be supplied");
+        Preconditions.checkNotNull(asyncExecutor, "An AsyncExecutor must be supplied");
+        Preconditions.checkNotNull(eventConsumer, "An event consumer supplier must be supplied");
+        Preconditions.checkNotNull(schemaSupplier, "An schema supplier must be supplied");
+
+        if (this.commitLogProvider == null)
+        {
+            // SidecarCdc should generally use SidecarCommitLogProvider to list and stream commit log segments over Sidecar http API
+            // but the builder is left open if user wishes to provide own implementation
+            this.commitLogProvider = new SidecarCommitLogProvider(clusterConfigProvider, sidecarCdcClient, downMonitor, replicationFactorSupplier);
+        }
+
+        return new SidecarCdc(this);
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCassandraClient.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCassandraClient.java
new file mode 100644
index 00000000..96c90228
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCassandraClient.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+import com.datastax.driver.core.ResultSetFuture;
+import org.apache.cassandra.bridge.TokenRange;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface defining read and write operations to Cassandra used by the `SidecarStatePersister`
+ */
+public interface SidecarCdcCassandraClient
+{
+    SidecarCdcCassandraClient STUB = new SidecarCdcCassandraClient()
+    {
+        @Override
+        public List<ResultSetFuture> storeStateAsync(String jobId, TokenRange range, ByteBuffer buf, long timestamp)
+        {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public Stream<byte[]> loadStateForRange(String jobId, TokenRange range)
+        {
+            return Stream.empty();
+        }
+    };
+
+    /**
+     * Durably store the CDC state
+     *
+     * @param jobId     cdc job id
+     * @param range     cdc partition token range
+     * @param buf       serialized CDC state
+     * @param timestamp timestamp to use in the write mutation
+     * @return list of Cassandra client ResultSetFutures
+     */
+    List<ResultSetFuture> storeStateAsync(@NotNull String jobId,
+                                          @NotNull TokenRange range,
+                                          @NotNull ByteBuffer buf,
+                                          long timestamp);
+
+    /**
+     * @param jobId      cdc job id
+     * @param tokenRange cdc partition token range
+     * @return stream of one or more serialized CDC state objects that overlap with the TokenRange
+     */
+    Stream<byte[]> loadStateForRange(String jobId, @Nullable TokenRange tokenRange);
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcClient.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcClient.java
new file mode 100644
index 00000000..16ae3eda
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcClient.java
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import o.a.c.sidecar.client.shaded.common.utils.HttpRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.cdc.stats.ICdcStats;
+import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.sidecar.client.SidecarClient;
+import org.apache.cassandra.sidecar.client.SidecarInstance;
+import org.apache.cassandra.sidecar.client.StreamBuffer;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.exceptions.TransportFailureException;
+import org.apache.cassandra.spark.utils.ThrowableUtils;
+import org.apache.cassandra.spark.utils.streaming.StreamConsumer;
+
+public class SidecarCdcClient
+{
+    final Sidecar.ClientConfig config;
+    final SidecarClient sidecarClient;
+    final ICdcStats stats;
+
+    public SidecarCdcClient(Sidecar.ClientConfig config,
+                            SidecarClient sidecarClient,
+                            ICdcStats stats)
+    {
+        this.config = config;
+        this.sidecarClient = sidecarClient;
+        this.stats = stats;
+    }
+
+    public CompletableFuture<List<CommitLog>> listCdcCommitLogSegments(CassandraInstance instance)
+    {
+        return sidecarClient.listCdcSegments(toSidecarInstance(instance))
+                            .thenApply(
+                            response ->
+                            response.segmentsInfo()
+                                    .stream()
+                                    .map(segment -> (CommitLog) new SidecarCdcCommitLogSegment(this, instance, segment, config))
+                                    .collect(Collectors.toList())
+                            ).exceptionally(throwable -> {
+            Throwable cause = ThrowableUtils.rootCause(throwable);
+            if (cause instanceof TransportFailureException.Nonretryable
+                && ((TransportFailureException.Nonretryable) cause).isNotFound())
+            {
+                // Rescue the 404 not found exception - it is a permitted error
+                return Collections.emptyList();
+            }
+            // Rethrow the other exception
+            if (throwable instanceof Error)
+            {
+                throw (Error) throwable;
+            }
+            throw new RuntimeException(cause);
+        });
+    }
+
+    public void streamCdcCommitLogSegment(CassandraInstance instance, String segment, HttpRange httpRange, StreamConsumer streamConsumer)
+    {
+        sidecarClient.streamCdcSegments(toSidecarInstance(instance), segment, httpRange, new org.apache.cassandra.sidecar.client.StreamConsumer()
+        {
+            @Override
+            public void onRead(StreamBuffer streamBuffer)
+            {
+                streamConsumer.onRead(new org.apache.cassandra.spark.utils.streaming.StreamBuffer()
+                {
+                    @Override
+                    public void getBytes(int index, ByteBuffer destination, int length)
+                    {
+                        streamBuffer.copyBytes(index, destination, length);
+                    }
+
+                    @Override
+                    public void getBytes(int index, byte[] destination, int destinationIndex, int length)
+                    {
+                        streamBuffer.copyBytes(index, destination, destinationIndex, length);
+                    }
+
+                    @Override
+                    public byte getByte(int index)
+                    {
+                        return streamBuffer.getByte(index);
+                    }
+
+                    @Override
+                    public int readableBytes()
+                    {
+                        return streamBuffer.readableBytes();
+                    }
+
+                    @Override
+                    public void release()
+                    {
+                        streamBuffer.release();
+                    }
+                });
+            }
+
+            @Override
+            public void onComplete()
+            {
+                streamConsumer.onEnd();
+            }
+
+            @Override
+            public void onError(Throwable throwable)
+            {
+                streamConsumer.onError(throwable);
+            }
+        });
+    }
+
+    protected SidecarInstance toSidecarInstance(CassandraInstance instance)
+    {
+        return new SidecarInstance()
+        {
+            @Override
+            public int port()
+            {
+                return config.effectivePort();
+            }
+
+            @Override
+            public String hostname()
+            {
+                return instance.nodeName();
+            }
+        };
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCommitLogSegment.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCommitLogSegment.java
new file mode 100644
index 00000000..b20ca3e4
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCommitLogSegment.java
@@ -0,0 +1,157 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.time.Duration;
+
+import o.a.c.sidecar.client.shaded.common.response.data.CdcSegmentInfo;
+import o.a.c.sidecar.client.shaded.common.utils.HttpRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.cdc.stats.ICdcStats;
+import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.spark.data.FileType;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.utils.streaming.CassandraFileSource;
+import org.apache.cassandra.spark.utils.streaming.StreamConsumer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * The SidecarCdcCommitLogSegment provides a CommitLog source for reading the
+ * CommitLog segments over the Sidecar HTTP API.
+ */
+public class SidecarCdcCommitLogSegment implements CommitLog
+{
+    private final CassandraInstance instance;
+    private final CdcSegmentInfo segment;
+    private final CassandraFileSource<CommitLog> source;
+    private final ICdcStats stats;
+
+    public SidecarCdcCommitLogSegment(SidecarCdcClient sidecar,
+                                      CassandraInstance instance,
+                                      CdcSegmentInfo segment,
+                                      Sidecar.ClientConfig clientConfig)
+    {
+        this.instance = instance;
+        this.segment = segment;
+        this.stats = sidecar.stats;
+
+        SidecarCdcCommitLogSegment thisLog = this;
+        this.source = new CassandraFileSource<CommitLog>()
+        {
+            public void request(long start, long end, StreamConsumer consumer)
+            {
+                sidecar.streamCdcCommitLogSegment(instance, segment.name, HttpRange.of(start, end), consumer);
+            }
+
+            public CommitLog cassandraFile()
+            {
+                return thisLog;
+            }
+
+            public long maxBufferSize()
+            {
+                return clientConfig.maxBufferSize();
+            }
+
+            public long chunkBufferSize()
+            {
+                return clientConfig.chunkBufferSize(fileType());
+            }
+
+            public FileType fileType()
+            {
+                return FileType.COMMITLOG;
+            }
+
+            public long size()
+            {
+                return segment.idx;
+            }
+
+            @Nullable
+            @Override
+            public Duration timeout()
+            {
+                int timeout = clientConfig.timeoutSeconds();
+                return timeout <= 0 ? null : Duration.ofSeconds(timeout);
+            }
+        };
+    }
+
+    public String name()
+    {
+        return segment.name;
+    }
+
+    public String path()
+    {
+        return "./" + segment.name;
+    }
+
+    public long maxOffset()
+    {
+        return segment.idx;
+    }
+
+    @Override
+    public long length()
+    {
+        return segment.size;
+    }
+
+    @Override
+    public boolean completed()
+    {
+        return segment.completed;
+    }
+
+    public CassandraFileSource<CommitLog> source()
+    {
+        return source;
+    }
+
+    public CassandraInstance instance()
+    {
+        return instance;
+    }
+
+    public ICdcStats stats()
+    {
+        return stats;
+    }
+
+    public void close()
+    {
+
+    }
+
+    @Override
+    public String toString()
+    {
+        return '{' +
+               "\"node\": \"" + instance.nodeName() + "\"," +
+               "\"dc\": \"" + instance.dataCenter() + "\"," +
+               "\"token\": \"" + instance.token() + "\"," +
+               "\"log\": \"" + segment.name + "\"," +
+               "\"idx\": \"" + segment.idx + "\"," +
+               "\"size\": \"" + segment.size + '"' +
+               '}';
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcOptions.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcOptions.java
new file mode 100644
index 00000000..1caa0697
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcOptions.java
@@ -0,0 +1,168 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.time.Duration;
+import java.util.Collections;
+import java.util.Map;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface SidecarCdcOptions
+{
+    String DEFAULT_JOB_ID = "test-job";
+    int DEFAULT_MAX_WATERMARKER_SIZE = 400000;
+
+    SidecarCdcOptions DEFAULT = new SidecarCdcOptions()
+    {
+    };
+
+    enum TopicFormatType
+    {
+        STATIC, KEYSPACE, KEYSPACETABLE, TABLE, MAP
+    }
+
+    @Nullable
+    default String kafkaTopic()
+    {
+        return null;
+    }
+
+    @NotNull
+    default TopicFormatType topicFormat()
+    {
+        return TopicFormatType.STATIC;
+    }
+
+    default boolean cdcEnabled()
+    {
+        return true;
+    }
+
+    default String jobId()
+    {
+        return DEFAULT_JOB_ID;
+    }
+
+    default Map<String, Object> kafkaConfigs()
+    {
+        return Collections.emptyMap();
+    }
+
+    default Map<String, Object> cdcConfigs()
+    {
+        return Collections.emptyMap();
+    }
+
+    default boolean logOnly()
+    {
+        return false;
+    }
+
+    default String dc()
+    {
+        return "DATACENTER1";
+    }
+
+    default Duration watermarkWindow()
+    {
+        return Duration.ofHours(4);
+    }
+
+    /**
+     * @return max Kafka record size in bytes. If value is non-negative then the KafkaPublisher will chunk larger records into multiple messages.
+     */
+    default int maxRecordSizeBytes()
+    {
+        return -1;
+    }
+
+    /**
+     * @return "zstd" to enable compression on large blobs, or null or empty string if disabled.
+     */
+    @Nullable
+    default String compression()
+    {
+        return null;
+    }
+
+    /**
+     * @return true if Kafka publisher should fail if Kafka client returns "record too large" error.
+     */
+    default boolean failOnRecordTooLargeError()
+    {
+        return false;
+    }
+
+    /**
+     * @return true if Kafka publisher should fail if Kafka client returns any other error.
+     */
+    default boolean failOnKafkaError()
+    {
+        return true;
+    }
+
+    /**
+     * Initialization of tables and loading config takes some time, returns if the config
+     * is ready to be loaded or not.
+     *
+     * @return true if config is ready to be read.
+     */
+    default boolean isConfigReady()
+    {
+        return true;
+    }
+
+    default Duration minDelayBetweenMicroBatches()
+    {
+        return Duration.ofMillis(1000);
+    }
+
+    default int maxCommitLogsPerInstance()
+    {
+        return 4;
+    }
+
+    /**
+     * @return the maximum number of entries to hold in the watermarker state for mutations that are have not achieved the consistency level.
+     * Each entry is an MD5 with a byte integer, approximately 30-60 bytes per entry before compression.
+     */
+    default int maxWatermarkerSize()
+    {
+        return DEFAULT_MAX_WATERMARKER_SIZE;
+    }
+
+    /**
+     * @return true if CDC state should be persisted to Cassandra.
+     */
+    default boolean persistEnabled()
+    {
+        return true;
+    }
+
+    /**
+     * @return the delay in millis between persist calls.
+     */
+    default Duration persistDelay()
+    {
+        return Duration.ofMillis(1000);
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcStats.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcStats.java
new file mode 100644
index 00000000..3e029311
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcStats.java
@@ -0,0 +1,277 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+public interface SidecarCdcStats
+{
+    SidecarCdcStats STUB = new SidecarCdcStats()
+    {
+    };
+
+    /**
+     * Cdc is enabled.
+     */
+    default void captureCdcEnabled()
+    {
+    }
+
+    /**
+     * Cdc disabled and CdcPublisher will not be started.
+     */
+    default void captureCdcDisabled()
+    {
+    }
+
+    // cdc lifecycle stats
+
+    /**
+     * CdcPublisher started successfully.
+     *
+     * @param numConsumers number of Cdc consumers started
+     */
+    default void captureCdcStarted(int numConsumers)
+    {
+    }
+
+    /**
+     * CdcPublisher failed to start.
+     *
+     * @param t throwable
+     */
+    default void captureCdcStartFailure(Throwable t)
+    {
+    }
+
+    /**
+     * CdcConsumer started.
+     */
+    default void captureCdcConsumerStarted()
+    {
+    }
+
+    /**
+     * CdcConsumer stopped.
+     */
+    default void captureCdcConsumerStopped()
+    {
+    }
+
+    /**
+     * Cdc or Kafka config change resulting in Cdc restart.
+     */
+    default void captureCdcConfigChange()
+    {
+    }
+
+    /**
+     * Cassandra cluster topology changed resulting in Cdc restart.
+     */
+    default void captureCdcClusterTopologyChange()
+    {
+    }
+
+    /**
+     * Cdc gained ownership for a token range.
+     */
+    default void captureCdcTokenRangeGained()
+    {
+    }
+
+    /**
+     * Cdc lost ownership for a token range.
+     */
+    default void captureCdcTokenRangeLost()
+    {
+    }
+
+    /**
+     * CdcPublisher restarted.
+     */
+    default void captureCdcRestart()
+    {
+    }
+
+    /**
+     * CdcPublisher stopped.
+     */
+    default void captureCdcStopped()
+    {
+    }
+
+    /**
+     * CdcPublisher failed to stop gracefully.
+     *
+     * @param t throwable
+     */
+    default void captureCdcStopFailed(Throwable t)
+    {
+    }
+
+    /**
+     * CdcConsumer read from state.
+     *
+     * @param count number of state objects.
+     * @param len   byte length of state.
+     */
+    default void captureCdcConsumerReadFromState(int count, int len)
+    {
+    }
+
+    default void captureCdcStateDeserializationFailure()
+    {
+    }
+
+    /**
+     * New blank CdcConsumer initialized.
+     */
+    default void captureNewBlankCdcConsumer()
+    {
+    }
+
+    // cdc consumer stats
+
+    /**
+     * Cdc consumer completed.
+     *
+     * @param epoch            epoch number, monotonically increasing 64-bit signed integer.
+     * @param numDownInstances number of down instances
+     * @param numTables        number of cached CDC enabled tables
+     * @param runtimeNanos     runtime of the previous epoch in nanoseconds
+     */
+    default void captureCdcNextEpoch(long epoch, int numDownInstances, int numTables, long runtimeNanos)
+    {
+
+    }
+
+    /**
+     * Single Cdc event processed.
+     */
+    default void captureCdcEventProcessed()
+    {
+    }
+
+    /**
+     * Recoverable Error detected in the CdcConsumer.
+     */
+    default void captureRecoverableCdcError(Throwable t)
+    {
+    }
+
+    /**
+     * Unrecoverable Error detected in the CdcConsumer causing it to stop.
+     */
+    default void captureUnrecoverableCdcError(Throwable t)
+    {
+    }
+
+    // state persist stats
+
+    /**
+     * Kafka queued events flushed.
+     *
+     * @param timeNanos time taken to flush in nanoseconds.
+     */
+    default void captureKafkaFlushTime(long timeNanos)
+    {
+    }
+
+    /**
+     * State persister backed up and not keeping up with persist cadence.
+     *
+     * @param numTasks number of active flush tasks queued.
+     */
+    default void capturePersistBackedUp(int numTasks)
+    {
+    }
+
+    /**
+     * Persist state request to storage.
+     *
+     * @param len byte length of state
+     */
+    default void capturePersistingCdcStateLength(int len)
+    {
+    }
+
+    /**
+     * Persist request succeeded.
+     *
+     * @param timeNanos time in nanos taken to persist.
+     */
+    default void capturePersistSucceeded(long timeNanos)
+    {
+    }
+
+    /**
+     * Persist failed with error.
+     *
+     * @param t throwable
+     */
+    default void capturePersistFailed(Throwable t)
+    {
+    }
+
+    /**
+     * Schema has been published.
+     */
+    default void capturePublishedSchema()
+    {
+    }
+
+    /**
+     * Cdc state has been written through http api.
+     *
+     * @param len length of the request body
+     */
+    default void captureCdcStatePutRequest(int len)
+    {
+    }
+
+    /**
+     * PutCdcStateHandler failed to write cdc state to store.
+     */
+    default void captureCdcStatePutRequestFailure()
+    {
+    }
+
+    /**
+     * Cdc state has been read through the http api.
+     *
+     * @param count number of Cdc state objects returned
+     * @param len   length of the response body
+     */
+    default void captureCdcStateGetRequest(int count, int len)
+    {
+    }
+
+    /**
+     * A Cdc enabled table is not enabled in the Schema.instance singleton, this is a critical alert as the table will skipped when reading the commit log.
+     */
+    default void captureCdcTableNotEnabled()
+    {
+    }
+
+    /**
+     * cdc_on_repair is enabled in the yaml file and should be disabled.
+     */
+    default void captureCdcOnRepairEnabled()
+    {
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProvider.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProvider.java
new file mode 100644
index 00000000..d6954022
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProvider.java
@@ -0,0 +1,143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.google.common.collect.Range;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.cdc.api.CommitLogProvider;
+import org.apache.cassandra.spark.data.ReplicationFactor;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.data.partitioner.CassandraRing;
+import org.apache.cassandra.spark.data.partitioner.Partitioner;
+import org.apache.cassandra.spark.utils.FutureUtils;
+import org.apache.cassandra.spark.utils.ThrowableUtils;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * The SidecarCommitLogProvider implements a CommitLogProvider for listing and reading
+ * CommitLog segments over the Sidecar HTTP APIs.
+ * This class uses the `CassandraRing` object to only select CassandraInstance objects
+ * that overlap with the TokenRange supplied.
+ */
+public class SidecarCommitLogProvider implements CommitLogProvider
+{
+    private static final Logger LOGGER = LoggerFactory.getLogger(SidecarCommitLogProvider.class);
+
+    private final ClusterConfigProvider clusterConfigProvider;
+    private final SidecarCdcClient sidecarCdcClient;
+    private final SidecarDownMonitor downMonitor;
+    private final Predicate<CassandraInstance> dcFilter;
+    private final ReplicationFactorSupplier replicationFactorSupplier;
+
+    public SidecarCommitLogProvider(ClusterConfigProvider clusterConfigProvider,
+                                    SidecarCdcClient sidecarCdcClient,
+                                    SidecarDownMonitor downMonitor,
+                                    ReplicationFactorSupplier replicationFactorSupplier)
+    {
+        this.clusterConfigProvider = clusterConfigProvider;
+        this.sidecarCdcClient = sidecarCdcClient;
+        this.downMonitor = downMonitor;
+        this.replicationFactorSupplier = replicationFactorSupplier;
+        this.dcFilter = inst -> {
+            String dc = clusterConfigProvider.dc();
+            return dc == null || inst.dataCenter().equalsIgnoreCase(dc);
+        };
+    }
+
+    protected CassandraRing ring()
+    {
+        Set<CassandraInstance> cluster = clusterConfigProvider.getCluster()
+                                         .stream()
+                                         .filter(dcFilter)
+                                         .collect(Collectors.toSet());
+        Partitioner partitioner = clusterConfigProvider.partitioner();
+        ReplicationFactor rf = replicationFactorSupplier.getMaximalReplicationFactor();
+        return new CassandraRing(partitioner, "keyspace", rf, cluster);
+    }
+
+    protected static Range<BigInteger> toGuavaRange(TokenRange range)
+    {
+        return Range.openClosed(range.lowerEndpoint(), range.upperEndpoint());
+    }
+
+    @Override
+    public Stream<CommitLog> logs(@Nullable TokenRange tokenRange)
+    {
+        //TODO: a future improvement could read CommitLog directly from disk if CassandraInstance is local
+        List<CassandraInstance> instances;
+        if (tokenRange != null)
+        {
+            // find only Cassandra instances that overlap with range filter
+            instances = ring().getSubRanges(toGuavaRange(tokenRange)).asMapOfRanges().values().stream()
+                              .flatMap(Collection::stream)
+                              .collect(Collectors.toList());
+        }
+        else
+        {
+            instances = new ArrayList<>(ring().instances());
+        }
+
+        Set<CassandraInstance> replicas = instances.stream()
+                                                   .filter(dcFilter)
+                                                   .filter(downMonitor::isUp)
+                                                   .collect(Collectors.toSet());
+
+        List<CompletableFuture<List<CommitLog>>> futures = replicas
+                                                           .stream()
+                                                           .map(this::listInstance)
+                                                           .collect(Collectors.toList());
+
+        // block to list replicas
+        List<List<CommitLog>> replicaLogs = FutureUtils.awaitAll(
+        futures,
+        true,
+        (throwable -> LOGGER.warn("Failed to list CDC commit logs on instance", (ThrowableUtils.rootCause(throwable))))
+        );
+
+        return replicaLogs.stream().flatMap(Collection::stream);
+    }
+
+    protected CompletableFuture<List<CommitLog>> listInstance(CassandraInstance instance)
+    {
+        return sidecarCdcClient
+               .listCdcCommitLogSegments(instance)
+               .whenComplete((response, throwable) -> {
+                   if (response == null || throwable != null)
+                   {
+                       LOGGER.warn("Failed to list commit log segments on instance nodeName={}", instance.nodeName(), throwable);
+                       downMonitor.hintDown(instance);
+                   }
+               });
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarDownMonitor.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarDownMonitor.java
new file mode 100644
index 00000000..8f9370b8
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarDownMonitor.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+
+/**
+ * This interface provides information about the health of other Sidecar instances.
+ * CDC attempts to read from all replicas and is slowed by retrying requests on Sidecar instances that are already known to be DOWN,
+ * therefore we skip DOWN instances and only retry when they are known to be healthy again via some asynchronous mechanism.
+ */
+public interface SidecarDownMonitor
+{
+    SidecarDownMonitor STUB = new SidecarDownMonitor()
+    {
+        @Override
+        public boolean isDown(CassandraInstance instance)
+        {
+            return false;
+        }
+
+        @Override
+        public void hintDown(CassandraInstance instance)
+        {
+
+        }
+    };
+
+    /**
+     * @param instance the CassandraInstance
+     * @return true if the CassandraInstance is known to be not DOWN.
+     */
+    default boolean isUp(CassandraInstance instance)
+    {
+        return !isDown(instance);
+    }
+
+    /**
+     * @param instance the CassandraInstance
+     * @return true if the CassandraInstance is known to be DOWN.
+     */
+    boolean isDown(CassandraInstance instance);
+
+    /**
+     * Pass a hint down to the implementation that the CassandraInstance might be DOWN.
+     * It is up to the implementation to take this as canonical or take further action to detect the health.
+     *
+     * @param instance the CassandraInstance
+     */
+    void hintDown(CassandraInstance instance);
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersister.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersister.java
new file mode 100644
index 00000000..ad4c34d5
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersister.java
@@ -0,0 +1,434 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.google.common.annotations.VisibleForTesting;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.datastax.driver.core.ResultSetFuture;
+import com.datastax.driver.core.ThreadLocalMonotonicTimestampGenerator;
+import org.apache.cassandra.bridge.CdcBridgeFactory;
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.CdcKryoRegister;
+import org.apache.cassandra.cdc.api.CdcOptions;
+import org.apache.cassandra.cdc.api.StatePersister;
+import org.apache.cassandra.cdc.state.CdcState;
+import org.apache.cassandra.spark.utils.AsyncExecutor;
+import org.apache.cassandra.spark.utils.ThrowableUtils;
+import org.apache.cassandra.util.CompressionUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * SidecarStatePersister buffers CDC state and flushes at regular time intervals, so we only write the latest CDC state and don't wastefully write expired data.
+ */
+public class SidecarStatePersister implements StatePersister
+{
+    private static final Logger LOGGER = LoggerFactory.getLogger(SidecarStatePersister.class);
+
+    // group latest state by jobId/token range, so we persist independently
+    protected final ConcurrentHashMap<PersistWrapper.Key, PersistWrapper> latestState = new ConcurrentHashMap<>();
+    protected final ConcurrentLinkedQueue<TimedFutureWrapper> activeFlush = new ConcurrentLinkedQueue<>();
+    private final ThreadLocalMonotonicTimestampGenerator timestampGenerator = new ThreadLocalMonotonicTimestampGenerator();
+    private final SidecarCdcOptions sidecarCdcOptions;
+    private final CdcOptions cdcOptions;
+    private final SidecarCdcCassandraClient cassandraClient;
+    private final SidecarCdcStats sidecarCdcStats;
+    private final AsyncExecutor asyncExecutor;
+    volatile long timerId = -1L;
+
+    public SidecarStatePersister(SidecarCdcOptions sidecarCdcOptions,
+                                 CdcOptions cdcOptions,
+                                 SidecarCdcStats sidecarCdcStats,
+                                 SidecarCdcCassandraClient cassandraClient,
+                                 AsyncExecutor asyncExecutor)
+    {
+        this.sidecarCdcOptions = sidecarCdcOptions;
+        this.cdcOptions = cdcOptions;
+        this.sidecarCdcStats = sidecarCdcStats;
+        this.cassandraClient = cassandraClient;
+        this.asyncExecutor = asyncExecutor;
+    }
+
+    // StatePersister implemented methods
+
+    @Override
+    public void persist(String jobId, int partitionId, @Nullable TokenRange tokenRange, @NotNull ByteBuffer buf)
+    {
+        PersistWrapper latest = new PersistWrapper(jobId, partitionId, tokenRange, buf, timestampGenerator.next());
+        PersistWrapper.Key key = latest.key();
+        if (!latest.equals(this.latestState.get(key)))
+        {
+            this.latestState.compute(key, (k, prev) -> !latest.equals(prev) ? latest : prev);
+        }
+    }
+
+    @NotNull
+    @Override
+    public List<CdcState> loadState(String jobId, int partitionId, @Nullable TokenRange tokenRange)
+    {
+        CompressionUtil compressionUtil = CdcBridgeFactory.get(cdcOptions.version()).compressionUtil();
+        List<Integer> sizes = new ArrayList<>();
+        // deserialize and merge the CDC state objects into canonical view
+        List<CdcState> result = loadStateForRange(jobId, tokenRange)
+                                .peek(bytes -> sizes.add(bytes.length))
+                                .map(bytes -> CdcState.deserialize(CdcKryoRegister.kryo(), compressionUtil, bytes))
+                                .collect(Collectors.toList());
+        int count = sizes.size();
+        int len = sizes.stream().mapToInt(i -> i).sum();
+        LOGGER.debug("Read CDC state from Cassandra jobId={} start={} end={} stateCount={} stateSize={}",
+                     jobId, tokenRange == null ? "null" : tokenRange.lowerEndpoint(), tokenRange == null ? "null" : tokenRange.upperEndpoint(), count, len);
+        sidecarCdcStats.captureCdcConsumerReadFromState(count, len);
+        return result;
+    }
+
+    @VisibleForTesting
+    public Stream<byte[]> loadStateForRange(String jobId, @Nullable TokenRange tokenRange)
+    {
+        return cassandraClient
+               .loadStateForRange(jobId, tokenRange);
+    }
+
+    /**
+     * Start the SidecarStatePersister to flush to Cassandra every `persistDelay()`.
+     */
+    public synchronized void start()
+    {
+        if (timerId >= 0)
+        {
+            // already running
+            return;
+        }
+        this.timerId = asyncExecutor.periodicTimer(this::persistToCassandra, sidecarCdcOptions.persistDelay().toMillis());
+    }
+
+    /**
+     * Stop the SidecarStatePersister gracefully, blocking to await for any pending flushes to complete.
+     */
+    public void stop()
+    {
+        stop(true);
+    }
+
+    public synchronized void stop(boolean flush)
+    {
+        if (this.timerId < 0)
+        {
+            // not running
+            return;
+        }
+
+        asyncExecutor.cancelTimer(this.timerId);
+        this.timerId = -1;
+
+        if (flush)
+        {
+            flush();
+        }
+    }
+
+    // internal methods
+
+    protected void persistToCassandra()
+    {
+        persistToCassandra(false);
+    }
+
+    protected void persistToCassandra(boolean force)
+    {
+        // clean-up finished futures
+        activeFlush.removeIf(wrapper -> {
+            if (wrapper.allDone())
+            {
+                try
+                {
+                    wrapper.await();
+                    sidecarCdcStats.capturePersistSucceeded(System.nanoTime() - wrapper.startTimeNanos);
+                }
+                catch (InterruptedException e)
+                {
+                    LOGGER.warn("Persist failed with InterruptedException", e);
+                    Thread.currentThread().interrupt();
+                    sidecarCdcStats.capturePersistFailed(e);
+                }
+                catch (Throwable throwable)
+                {
+                    LOGGER.warn("Persist failed", throwable);
+                    sidecarCdcStats.capturePersistFailed(throwable);
+                }
+                return true;
+            }
+            return false;
+        });
+
+        if (!force && !activeFlush.isEmpty())
+        {
+            // check for active requests so we don't get backed up
+            LOGGER.debug("CDC persist flush backed up, can't persist until active requests complete activeRequests={}", activeFlush.size());
+            sidecarCdcStats.capturePersistBackedUp(activeFlush.size());
+            return;
+        }
+
+        // drain the latestState map, so we don't persist multiple times wastefully
+        List<PersistWrapper> states = this.latestState
+                                      .keySet()
+                                      .stream()
+                                      .map(this.latestState::remove)
+                                      .filter(Objects::nonNull)
+                                      .collect(Collectors.toList());
+
+        if (states.isEmpty())
+        {
+            // nothing to persist
+            return;
+        }
+
+        states.stream()
+              .map(this::persistToCassandra)
+              .filter(Objects::nonNull)
+              .forEach(activeFlush::add);
+    }
+
+    @Nullable
+    protected TimedFutureWrapper persistToCassandra(@NotNull PersistWrapper state)
+    {
+        TokenRange range = state.tokenRange();
+        if (range == null)
+        {
+            LOGGER.warn("Cannot persist state with null token range");
+            return null;
+        }
+
+        try
+        {
+            LOGGER.debug("Persisting CDC state jobId={} partitionId={} start={} end={} sizeBytes={}",
+                         state.jobId,
+                         state.partitionId,
+                         range.lowerEndpoint(),
+                         range.upperEndpoint(),
+                         state.buf.remaining());
+
+            sidecarCdcStats.capturePersistingCdcStateLength(state.buf.remaining());
+            return new TimedFutureWrapper(cassandraClient.storeStateAsync(state.jobId, range, state.buf, state.timestamp));
+        }
+        catch (Throwable t)
+        {
+            LOGGER.error("Unexpected error persisting CDC state to Cassandra", t);
+            sidecarCdcStats.capturePersistFailed(t);
+            // we failed to persist, so add back to latestState map if not already overwritten
+            this.latestState.putIfAbsent(state.key(), state);
+            return null;
+        }
+    }
+
+    /**
+     * Flush active state persist calls
+     */
+    protected void flush()
+    {
+        // persist any buffered state and flush in-flight requests
+        persistToCassandra(true);
+        flushActiveSafe();
+    }
+
+    protected void flushActiveSafe()
+    {
+        try
+        {
+            flushActive();
+        }
+        catch (ExecutionException e)
+        {
+            LOGGER.warn("Failed to flush active CDC state", ThrowableUtils.rootCause(e));
+        }
+        catch (InterruptedException e)
+        {
+            Thread.currentThread().interrupt();
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Flush active in-flight persist writes.
+     *
+     * @throws ExecutionException
+     * @throws InterruptedException
+     */
+    protected void flushActive() throws ExecutionException, InterruptedException
+    {
+        for (TimedFutureWrapper wrapper : activeFlush)
+        {
+            wrapper.await();
+        }
+    }
+
+    // helper classes
+
+    protected static class PersistWrapper implements Comparable<PersistWrapper>
+    {
+        final String jobId;
+        final int partitionId;
+        @Nullable
+        final TokenRange tokenRange;
+        final ByteBuffer buf;
+        final long timestamp;
+
+        protected static class Key
+        {
+            private final String jobId;
+            private final TokenRange tokenRange;
+
+            protected Key(String jobId,
+                          TokenRange tokenRange)
+            {
+                this.jobId = jobId;
+                this.tokenRange = tokenRange;
+            }
+
+            public int hashCode()
+            {
+                return Objects.hash(jobId, tokenRange);
+            }
+
+            public boolean equals(Object o)
+            {
+                if (this == o)
+                {
+                    return true;
+                }
+
+                if (o == null || getClass() != o.getClass())
+                {
+                    return false;
+                }
+
+                PersistWrapper.Key other = (PersistWrapper.Key) o;
+                return jobId.equals(other.jobId)
+                       && Objects.equals(tokenRange, other.tokenRange);
+            }
+        }
+
+        protected PersistWrapper(String jobId,
+                                 int partitionId,
+                                 @Nullable TokenRange tokenRange,
+                                 ByteBuffer buf,
+                                 long timestamp)
+        {
+            this.jobId = jobId;
+            this.partitionId = partitionId;
+            this.tokenRange = tokenRange;
+            this.buf = buf;
+            this.timestamp = timestamp;
+        }
+
+        @Nullable
+        public TokenRange tokenRange()
+        {
+            return tokenRange;
+        }
+
+        public Key key()
+        {
+            return new Key(jobId, tokenRange());
+        }
+
+        @Override
+        public int compareTo(@NotNull PersistWrapper o)
+        {
+            return Long.compare(this.timestamp, o.timestamp);
+        }
+
+        @Override
+        public int hashCode()
+        {
+            return Objects.hash(jobId, tokenRange());
+        }
+
+        @Override
+        public boolean equals(Object o)
+        {
+            if (this == o)
+            {
+                return true;
+            }
+
+            if (o == null || getClass() != o.getClass())
+            {
+                return false;
+            }
+
+            PersistWrapper other = (PersistWrapper) o;
+            return jobId.equals(other.jobId)
+                   && Objects.equals(tokenRange(), other.tokenRange())
+                   && this.buf.equals(other.buf);
+        }
+
+        public static PersistWrapper max(PersistWrapper w1, PersistWrapper w2)
+        {
+            if (w1 == null)
+            {
+                return w2;
+            }
+            else if (w2 == null)
+            {
+                return w1;
+            }
+
+            return w1.compareTo(w2) > 0 ? w1 : w2;
+        }
+    }
+
+    protected static class TimedFutureWrapper
+    {
+        protected final List<ResultSetFuture> futures;
+        protected final long startTimeNanos;
+
+        protected TimedFutureWrapper(List<ResultSetFuture> futures)
+        {
+            this.futures = futures;
+            this.startTimeNanos = System.nanoTime();
+        }
+
+        public void await() throws ExecutionException, InterruptedException
+        {
+            for (ResultSetFuture future : futures)
+            {
+                future.get();
+            }
+        }
+
+        public boolean allDone()
+        {
+            return futures.stream().allMatch(Future::isDone);
+        }
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/CassandraClientSourceTest.java b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/CassandraClientSourceTest.java
new file mode 100644
index 00000000..0a3bbafb
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/CassandraClientSourceTest.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import com.datastax.driver.core.BoundStatement;
+import com.datastax.driver.core.PreparedStatement;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.Session;
+import com.datastax.driver.core.Statement;
+import org.apache.cassandra.bridge.CassandraTypesImplementation;
+import org.apache.cassandra.cdc.msg.Value;
+import org.apache.cassandra.spark.data.CassandraTypes;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class CassandraClientSourceTest
+{
+    private static final CassandraTypes TYPES = new CassandraTypesImplementation();
+
+    @Test
+    public void testGetReadQuery()
+    {
+        String query = CassandraClientSource.getReadQuery("testKeyspace", "testTable", Arrays.asList("a", "b"), Arrays.asList("c", "d", "e"));
+        String expectedQuery = "SELECT a,b from testKeyspace.testTable where c = ? , d = ? , e = ?";
+        assertEquals(expectedQuery, query);
+    }
+
+    @Test
+    public void testGetPrimaryKeyObjects()
+    {
+        List<Value> primaryKeyColumns = Arrays.asList(
+        new TestValue("ks", "a", "int", TYPES.aInt().serialize(1)),
+        new TestValue("ks", "b", "text", ByteBuffer.wrap("test".getBytes(StandardCharsets.UTF_8)))
+        );
+        Object[] primaryKeyValues = CassandraClientSource.getPrimaryKeyObjects(TYPES, primaryKeyColumns);
+        assertEquals(1, primaryKeyValues[0]);
+        assertEquals("test", primaryKeyValues[1]);
+    }
+
+    @Test
+    public void testReadFromCassandra()
+    {
+        CassandraClientSource cassandraSource = new CassandraClientSource(getMockSession(), TYPES);
+
+        // column with name "a" of type int with value 1
+        List<Value> primaryKeyColumns = Collections.singletonList(new TestValue("ks", "a", "int", TYPES.aInt().serialize(1)));
+        List<ByteBuffer> result = cassandraSource.readFromCassandra("testKeyspace", "testTable", Collections.singletonList("b"), primaryKeyColumns);
+        assertEquals(100, result.get(0).getInt(result.get(0).position()));
+    }
+
+    // mock session that returns 100 on execution of query
+    private static Session getMockSession()
+    {
+        Session session = mock(Session.class);
+        // mock row
+        Row row = mock(Row.class);
+        when(row.getBytesUnsafe(anyString())).thenReturn(TYPES.aInt().serialize(100));
+
+        // mock result set
+        ResultSet resultSet = mock(ResultSet.class);
+        when(resultSet.one()).thenAnswer(invocation -> row);
+
+        // mock prepared statement
+        PreparedStatement preparedStatement = mock(PreparedStatement.class);
+        when(preparedStatement.bind(any())).thenAnswer(invocation -> mock(BoundStatement.class));
+
+        // mock session
+        when(session.prepare(anyString())).then(invocation -> preparedStatement);
+        when(session.execute(any(Statement.class))).thenAnswer(invocation -> resultSet);
+        doNothing().when(session).close();
+        return session;
+    }
+
+    private static class TestValue extends Value
+    {
+        private TestValue(String keyspace, String columnName, String columnType, ByteBuffer value)
+        {
+            super(keyspace, columnName, columnType, value);
+        }
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProviderTests.java b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProviderTests.java
new file mode 100644
index 00000000..c4190c42
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProviderTests.java
@@ -0,0 +1,196 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import com.google.common.collect.ImmutableMap;
+import org.apache.commons.lang3.mutable.MutableInt;
+import org.junit.jupiter.api.Test;
+
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.spark.data.ReplicationFactor;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.data.partitioner.Partitioner;
+import org.jetbrains.annotations.NotNull;
+import org.mockito.stubbing.Answer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class SidecarCommitLogProviderTests
+{
+    private static final List<CassandraInstance> INSTANCES = Arrays.asList(
+    new CassandraInstance("0", "local1", "DC1"),
+    new CassandraInstance("100", "local2", "DC1"),
+    new CassandraInstance("200", "local3", "DC1"),
+    new CassandraInstance("300", "local4", "DC1"),
+    new CassandraInstance("400", "local5", "DC1"),
+    new CassandraInstance("500", "local6", "DC1"),
+    new CassandraInstance("1", "local7", "DC2"),
+    new CassandraInstance("101", "local8", "DC2"),
+    new CassandraInstance("201", "local9", "DC2"),
+    new CassandraInstance("301", "local10", "DC2"),
+    new CassandraInstance("401", "local11", "DC2"),
+    new CassandraInstance("501", "local12", "DC2")
+    );
+
+    @Test
+    public void testCommitLogProvider()
+    {
+        int aPrimeNumber = 13;
+        CassandraInstance instance1 = INSTANCES.get(0);
+        CassandraInstance instance2 = INSTANCES.get(1);
+        CassandraInstance instance3 = INSTANCES.get(2);
+        CassandraInstance instance4 = INSTANCES.get(3);
+        CassandraInstance instance5 = INSTANCES.get(4);
+        CassandraInstance instance6 = INSTANCES.get(5);
+
+        ClusterConfigProvider clusterConfigProvider = getClusterConfigProvider();
+        SidecarCdcClient sidecarCdcClient = mock(SidecarCdcClient.class);
+        Map<CassandraInstance, Integer> instanceListCount = new HashMap<>();
+        MutableInt segmentIdGenerator = new MutableInt(0);
+        Answer<CompletableFuture<List<CommitLog>>> listCommitLogAnswer = invocation -> {
+            CassandraInstance instance = invocation.getArgument(0, CassandraInstance.class);
+            instanceListCount.compute(instance, (key, prev) -> prev == null ? 1 : prev + 1);
+            int instanceId = Integer.parseInt(instance.nodeName().substring(5));
+            int numLogs = instanceId * 13;
+            List<CommitLog> logs = IntStream.rangeClosed(1, numLogs)
+                                            .mapToObj(segmentId -> mockCommitLog(instance, segmentIdGenerator.getAndAdd(1)))
+                                            .collect(Collectors.toList());
+            return CompletableFuture.completedFuture(logs);
+        };
+
+        when(sidecarCdcClient.listCdcCommitLogSegments(any(CassandraInstance.class))).thenAnswer(listCommitLogAnswer);
+        SidecarCommitLogProvider commitLogProvider = getSidecarCommitLogProvider(clusterConfigProvider, sidecarCdcClient);
+
+        // list logs on instance1, instance2, instance3
+        TokenRange tokenRange = TokenRange.openClosed(
+        new BigInteger("-50"),
+        new BigInteger("-10")
+        );
+        List<CommitLog> logs = commitLogProvider
+                               .logs(tokenRange)
+                               .sorted()
+                               .collect(Collectors.toList());
+        int expectedNumberOfLogs = aPrimeNumber + (2 * aPrimeNumber) + (3 * aPrimeNumber);
+        assertEquals(expectedNumberOfLogs, logs.size());
+        IntStream.range(0, logs.size())
+                 .forEach(index -> assertEquals(index, logs.get(index).segmentId()));
+        assertEquals(3, instanceListCount.size());
+        assertEquals(1, instanceListCount.get(instance1));
+        assertEquals(1, instanceListCount.get(instance2));
+        assertEquals(1, instanceListCount.get(instance3));
+
+        // list logs on instance4, instance5, instance6
+        TokenRange tokenRange2 = TokenRange.openClosed(
+        new BigInteger("210"),
+        new BigInteger("280")
+        );
+        List<CommitLog> logs2 = commitLogProvider
+                                .logs(tokenRange2)
+                                .collect(Collectors.toList());
+        expectedNumberOfLogs = (4 * aPrimeNumber) + (5 * aPrimeNumber) + (6 * aPrimeNumber);
+        assertEquals(expectedNumberOfLogs, logs2.size());
+        IntStream.range(0, logs2.size())
+                 .forEach(index -> assertEquals(index + logs.size(), logs2.get(index).segmentId()));
+        assertEquals(6, instanceListCount.size());
+        assertEquals(1, instanceListCount.get(instance1));
+        assertEquals(1, instanceListCount.get(instance2));
+        assertEquals(1, instanceListCount.get(instance3));
+        assertEquals(1, instanceListCount.get(instance4));
+        assertEquals(1, instanceListCount.get(instance5));
+        assertEquals(1, instanceListCount.get(instance6));
+    }
+
+    @NotNull
+    private static SidecarCommitLogProvider getSidecarCommitLogProvider(ClusterConfigProvider clusterConfigProvider, SidecarCdcClient sidecarCdcClient)
+    {
+        ReplicationFactorSupplier replicationFactorSupplier = new ReplicationFactorSupplier()
+        {
+            @Override
+            public ReplicationFactor getReplicationFactor(String keyspace)
+            {
+                return new ReplicationFactor(ImmutableMap.of(
+                "class", "org.apache.cassandra.locator.NetworkTopologyStrategy",
+                "DC1", "3",
+                "DC2", "3"));
+            }
+
+            @Override
+            public ReplicationFactor getMaximalReplicationFactor()
+            {
+                return getReplicationFactor("ks");
+            }
+        };
+        return new SidecarCommitLogProvider(
+        clusterConfigProvider,
+        sidecarCdcClient,
+        SidecarDownMonitor.STUB,
+        replicationFactorSupplier
+        );
+    }
+
+    private static CommitLog mockCommitLog(CassandraInstance instance, long segmentId)
+    {
+        CommitLog commitLog = mock(CommitLog.class);
+        when(commitLog.instance()).thenReturn(instance);
+        when(commitLog.name()).thenReturn("CommitLog-6-" + segmentId + ".log");
+        when(commitLog.segmentId()).thenCallRealMethod();
+        return commitLog;
+    }
+
+    @NotNull
+    private static ClusterConfigProvider getClusterConfigProvider()
+    {
+        return new ClusterConfigProvider()
+        {
+            @Override
+            public String dc()
+            {
+                return "DC1";
+            }
+
+            @Override
+            public Set<CassandraInstance> getCluster()
+            {
+                return new HashSet<>(INSTANCES);
+            }
+
+            @Override
+            public Partitioner partitioner()
+            {
+                return Partitioner.Murmur3Partitioner;
+            }
+        };
+    }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersisterTest.java b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersisterTest.java
new file mode 100644
index 00000000..07468655
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersisterTest.java
@@ -0,0 +1,118 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+
+import com.datastax.driver.core.ResultSetFuture;
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.api.CdcOptions;
+import org.apache.cassandra.spark.utils.AsyncExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class SidecarStatePersisterTest
+{
+    private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor();
+
+    @Test
+    public void testStatePersister() throws InterruptedException
+    {
+        Map<TokenRange, byte[]> store = new ConcurrentHashMap<>();
+        CountDownLatch writeLatch = new CountDownLatch(1);
+        SidecarCdcCassandraClient cassandraClient = new SidecarCdcCassandraClient()
+        {
+            @Override
+            public List<ResultSetFuture> storeStateAsync(@NotNull String jobId, @NotNull TokenRange range, @NotNull ByteBuffer buf, long timestamp)
+            {
+                byte[] ar = new byte[buf.remaining()];
+                buf.get(ar);
+                store.put(range, ar);
+                ResultSetFuture future = mock(ResultSetFuture.class);
+                when(future.isDone()).thenReturn(true);
+                writeLatch.countDown();
+                return Collections.singletonList(future);
+            }
+
+            @Override
+            public Stream<byte[]> loadStateForRange(String jobId, @Nullable TokenRange tokenRange)
+            {
+                return Stream.of(store.get(tokenRange));
+            }
+        };
+        SidecarCdcOptions sidecarCdcOptions = new SidecarCdcOptions()
+        {
+            @Override
+            public Duration persistDelay()
+            {
+                return Duration.ofMillis(50);
+            }
+        };
+        AsyncExecutor asyncExecutor = AsyncExecutor.wrap(EXECUTOR_SERVICE);
+
+        // build and start SidecarStatePersister
+        SidecarStatePersister statePersister = new SidecarStatePersister(
+        sidecarCdcOptions,
+        CdcOptions.DEFAULT,
+        SidecarCdcStats.STUB,
+        cassandraClient,
+        asyncExecutor
+        );
+        assertEquals(-1, statePersister.timerId);
+        statePersister.start();
+        assertTrue(statePersister.timerId >= 0);
+
+        // write random data
+        byte[] data = new byte[1024];
+        ThreadLocalRandom.current().nextBytes(data);
+        TokenRange tokenRange = TokenRange.openClosed(BigInteger.ONE, BigInteger.valueOf(10L));
+        statePersister.persist("101", 0, tokenRange, ByteBuffer.wrap(data));
+
+        // wait for write to complete and verify data matches
+        writeLatch.await(5, TimeUnit.SECONDS);
+        List<byte[]> result = statePersister.loadStateForRange("101", tokenRange).collect(Collectors.toList());
+        assertEquals(1, result.size());
+        assertArrayEquals(data, result.get(0));
+
+        statePersister.stop();
+        assertEquals(-1, statePersister.timerId);
+    }
+}
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java
index a0b0922c..b3409cdf 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java
@@ -70,12 +70,12 @@ public class Cdc implements Closeable
     private final int partitionId;
     private final TokenRangeSupplier tokenRangeSupplier;
     private final TableIdLookup tableIdLookup;
-    private final SchemaSupplier schemaSupplier;
+    protected final SchemaSupplier schemaSupplier;
     private final CassandraSource cassandraSource;
     private final StatePersister statePersister;
     private final CdcOptions cdcOptions;
-    private final AsyncExecutor asyncExecutor;
-    private final CommitLogProvider commitLogProvider;
+    protected final AsyncExecutor asyncExecutor;
+    protected final CommitLogProvider commitLogProvider;
     private final ICdcStats stats;
     private final EventConsumer eventConsumer;
 
@@ -171,7 +171,7 @@ public class Cdc implements Closeable
         if (isRunning.get() && isRunning.compareAndSet(true, false))
         {
             LOGGER.info("Stopping CDC Consumer jobId={} partitionId={}", jobId, partitionId);
-            final CompletableFuture<Void> activeFuture = active.get();
+            CompletableFuture<Void> activeFuture = active.get();
             if (activeFuture != null && blocking)
             {
                 // block until active future completes
@@ -336,7 +336,7 @@ public class Cdc implements Closeable
 
     protected boolean epochsExceeded()
     {
-        final int maxEpochs = cdcOptions.maxEpochs();
+        int maxEpochs = cdcOptions.maxEpochs();
         return maxEpochs > 0 && this.currentState.epoch >= maxEpochs;
     }
 
@@ -371,7 +371,7 @@ public class Cdc implements Closeable
 
         try
         {
-            final ByteBuffer buf = serializeStateToBytes();
+            ByteBuffer buf = serializeStateToBytes();
             LOGGER.debug("Persisting Iterator state between micro-batch partitionId={} epoch={} size={}",
                          partitionId, cdcState.epoch, buf.remaining());
             statePersister.persist(jobId, partitionId, tokenRange, buf);
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java
index b6e9f3a3..d95315ed 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java
@@ -41,26 +41,28 @@ import org.jetbrains.annotations.Nullable;
 public class CdcBuilder
 {
     @NotNull
-    final String jobId;
-    final int partitionId;
+    protected final String jobId;
+    protected final int partitionId;
     @NotNull
     TokenRangeSupplier tokenRangeSupplier = () -> null;
     @NotNull
-    SchemaSupplier schemaSupplier;
+    protected SchemaSupplier schemaSupplier;
     @NotNull
     CassandraSource cassandraSource = CassandraSource.DEFAULT;
     @NotNull
     StatePersister statePersister = StatePersister.STUB;
     @NotNull
-    CdcOptions cdcOptions = CdcOptions.DEFAULT;
+    protected CdcOptions cdcOptions = CdcOptions.DEFAULT;
     @NotNull
     ICdcStats stats = ICdcStats.STUB;
+    // asyncExecutor is @Nullable at compile time but required to be @NotNull at runtime to build the Cdc object
+    @SuppressWarnings("NotNullFieldNotInitialized")
+    @NotNull
+    protected AsyncExecutor asyncExecutor = null;
     @Nullable
-    AsyncExecutor asyncExecutor = null;
-    @Nullable
-    CommitLogProvider commitLogProvider = null;
+    protected CommitLogProvider commitLogProvider = null;
     @NotNull
-    EventConsumer eventConsumer;
+    protected EventConsumer eventConsumer;
     @NotNull
     public TableIdLookup tableIdLookup = TableIdLookup.STUB;
 
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java
index a74ba3fa..54e73f18 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java
@@ -29,7 +29,7 @@ import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
 public class CdcKryoRegister
 {
     private static final ThreadLocal<Kryo> KRYO = ThreadLocal.withInitial(() -> {
-        final Kryo kryo = new Kryo();
+        Kryo kryo = new Kryo();
         new CdcKryoRegister().registerClasses(kryo);
         return kryo;
     });
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/TypeCache.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/TypeCache.java
new file mode 100644
index 00000000..7fde0ca3
--- /dev/null
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/TypeCache.java
@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.function.Supplier;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.cassandra.bridge.CassandraVersion;
+import org.apache.cassandra.bridge.CdcBridgeFactory;
+import org.apache.cassandra.cdc.api.KeyspaceTypeKey;
+import org.apache.cassandra.spark.data.CassandraTypes;
+import org.apache.cassandra.spark.data.CqlField;
+
+/**
+ * Caches Cassandra CqlField.CqlType objects, so they don't need to be re-created everytime. Keyed on keyspace and type to permit per keyspace UDT definitions.
+ */
+public class TypeCache
+{
+    private static final Logger LOGGER = LoggerFactory.getLogger(TypeCache.class);
+    protected volatile Cache<KeyspaceTypeKey, CqlField.CqlType> cqlTypeCache = null; // volatile needed for lazy-initialization
+    private static final int CACHE_CAPACITY = 1000;
+    private static final ConcurrentHashMap<CassandraVersion, TypeCache> VERSION_TYPE_CACHE = new ConcurrentHashMap<>(2);
+
+    private final Supplier<CassandraTypes> cassandraTypesSupplier;
+
+    protected TypeCache(Supplier<CassandraTypes> cassandraTypesSupplier)
+    {
+        this.cassandraTypesSupplier = cassandraTypesSupplier;
+    }
+
+    public CqlField.CqlType getType(String keyspace, String typeString)
+    {
+        maybeInit();
+        CqlField.CqlType result;
+        KeyspaceTypeKey key = KeyspaceTypeKey.of(keyspace, typeString);
+        try
+        {
+            result = cqlTypeCache.get(key, () -> getTypes().parseType(keyspace, typeString));
+        }
+        catch (CacheLoader.InvalidCacheLoadException | ExecutionException e)
+        {
+            LOGGER.warn("Unable to get the CQL type from cache.", e);
+            result = getTypes().parseType(typeString);
+            if (result == null)
+            {
+                throw new RuntimeException("Unable to parse type: " + typeString);
+            }
+            cqlTypeCache.put(key, result);
+        }
+        return result;
+    }
+
+    public CassandraTypes getTypes()
+    {
+        return cassandraTypesSupplier.get();
+    }
+
+    public static TypeCache get(CassandraVersion version)
+    {
+        return VERSION_TYPE_CACHE
+               .compute(version,
+                        (key, previous) ->
+                        new TypeCache(() -> CdcBridgeFactory.get(key).cassandraTypes())
+               );
+    }
+
+    private void maybeInit()
+    {
+        if (cqlTypeCache != null)
+        {
+            return;
+        }
+
+        synchronized (this)
+        {
+            if (cqlTypeCache != null)
+            {
+                return;
+            }
+
+            // using a manual cache since the parser is version dependent, see getCassandraBridge()
+            cqlTypeCache = CacheBuilder.newBuilder()
+                                       .initialCapacity(CACHE_CAPACITY / 2)
+                                       .maximumSize(CACHE_CAPACITY)
+                                       .removalListener(notification -> {
+                                           // Log at the info level: the event is not expected, but could happen.
+                                           // With the logs, we can check how frequent it happens.
+                                           LOGGER.info("Type is evicted from cache. type='{}'", notification.getKey());
+                                       })
+                                       .build();
+        }
+    }
+}
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java
index b245c6fa..e5cbdbd7 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java
@@ -79,16 +79,16 @@ public class CdcMessage
     @SuppressWarnings("unchecked")
     private static Function<String, CqlField.CqlType> typeProvider(CassandraTypes types, CdcEvent event)
     {
-        final List<Value> cols = ArrayUtils.combine(event.getPartitionKeys(),
-                                                    event.getClusteringKeys(),
-                                                    event.getStaticColumns(),
-                                                    event.getValueColumns());
-        final Map<String, CqlField.CqlType> typeMap = cols
-                                                      .stream()
-                                                      .collect(Collectors
-                                                               .toMap(v -> v.columnName,
-                                                                      v -> types.parseType(event.keyspace, v.columnType)
-                                                               ));
+        List<Value> cols = ArrayUtils.combine(event.getPartitionKeys(),
+                                              event.getClusteringKeys(),
+                                              event.getStaticColumns(),
+                                              event.getValueColumns());
+        Map<String, CqlField.CqlType> typeMap = cols
+                                                .stream()
+                                                .collect(Collectors
+                                                         .toMap(v -> v.columnName,
+                                                                v -> types.parseType(event.keyspace, v.columnType)
+                                                         ));
         return typeMap::get;
     }
 
@@ -134,7 +134,7 @@ public class CdcMessage
                .entrySet()
                .stream()
                .collect(Collectors.toMap(Map.Entry::getKey, entry -> {
-                   final CqlField.CqlCollection type = (CqlField.CqlCollection) typeProvider.apply(entry.getKey());
+                   CqlField.CqlCollection type = (CqlField.CqlCollection) typeProvider.apply(entry.getKey());
                    return entry.getValue().stream().map(ByteBuffer::duplicate).map(buf -> type.type().deserializeToJavaType(buf)).collect(Collectors.toList());
                }));
     }
diff --git a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java
index 04e9c88f..6fdcdc32 100644
--- a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java
+++ b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java
@@ -168,7 +168,7 @@ public class CdcTester
 
             // add default writer
             this.writers.add((tester, rows, writer) -> {
-                final long timestampMicros = TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());
+                long timestampMicros = TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());
                 IntStream.range(0, tester.numRows)
                          .forEach(i -> writer.accept(newUniqueRow(tester.schema, rows), timestampMicros));
             });
diff --git a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java
index 28c29c74..459a4e03 100644
--- a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java
+++ b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java
@@ -221,7 +221,7 @@ public class CdcTests
                                true);
             UUID tableId = Schema.instance.getTableMetadata(table.keyspace(), table.table()).id.asUUID();
             SchemaSupplier schemaSupplier = () -> CompletableFuture.completedFuture(ImmutableSet.of(table));
-            final AtomicReference<byte[]> state = new AtomicReference<>();
+            AtomicReference<byte[]> state = new AtomicReference<>();
             StatePersister statePersister = new StatePersister()
             {
                 public void persist(String jobId, int partitionId, @Nullable TokenRange tokenRange, @NotNull ByteBuffer buf)
@@ -254,7 +254,7 @@ public class CdcTests
                 CdcTester.testCommitLog.sync();
             };
 
-            final long startTime = System.currentTimeMillis();
+            long startTime = System.currentTimeMillis();
             try (Cdc cdc = Cdc.builder("101", 0, eventConsumer, schemaSupplier)
                               .withExecutor(CdcTests.ASYNC_EXECUTOR)
                               .withStatePersister(statePersister)
diff --git a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/TypeCacheTests.java b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/TypeCacheTests.java
new file mode 100644
index 00000000..56cf9283
--- /dev/null
+++ b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/TypeCacheTests.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import org.junit.jupiter.api.Test;
+
+import org.apache.cassandra.bridge.CassandraVersion;
+import org.apache.cassandra.spark.data.CassandraTypes;
+import org.apache.cassandra.spark.data.CqlField;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class TypeCacheTests
+{
+    @Test
+    public void testTypeCache()
+    {
+        TypeCache typeCache = TypeCache.get(CassandraVersion.FOURZERO);
+        assertNull(typeCache.cqlTypeCache);
+
+        CqlField.CqlType ksBigInt = typeCache.getType("ks", "bigint");
+        assertNotNull(typeCache.cqlTypeCache);
+        assertEquals("bigint", ksBigInt.cqlName());
+        assertEquals(1, typeCache.cqlTypeCache.size());
+        typeCache.getType("ks", "bigint");
+        typeCache.getType("ks", "bigint");
+        typeCache.getType("ks", "bigint");
+        assertEquals(1, typeCache.cqlTypeCache.size());
+
+        CqlField.CqlType ks2BigInt = typeCache.getType("ks2", "bigint");
+        assertEquals("bigint", ks2BigInt.cqlName());
+        assertSame(ksBigInt, ks2BigInt);
+
+        assertSame(typeCache.getType("ks", "int"), typeCache.getType("ks2", "int"));
+        assertSame(typeCache.getType("ks", "text"), typeCache.getType("ks2", "text"));
+        assertSame(typeCache.getType("ks", "boolean"), typeCache.getType("ks2", "boolean"));
+        assertSame(typeCache.getType("ks", "double"), typeCache.getType("ks2", "double"));
+        assertSame(typeCache.getType("ks", "float"), typeCache.getType("ks2", "float"));
+        assertEquals(12, typeCache.cqlTypeCache.size());
+
+        // test collections
+        assertInstanceOf(CqlField.CqlMap.class, typeCache.getType("ks", "map<text, int>"));
+        assertInstanceOf(CqlField.CqlList.class, typeCache.getType("ks", "list<ascii>"));
+        assertInstanceOf(CqlField.CqlSet.class, typeCache.getType("ks", "set<date>"));
+        assertInstanceOf(CqlField.CqlFrozen.class, typeCache.getType("ks", "frozen<set<blob>>"));
+        assertEquals(16, typeCache.cqlTypeCache.size());
+
+        // test udt
+        CassandraTypes cassandraTypes = typeCache.getTypes();
+        cassandraTypes.updateUDTs("ks", cassandraTypes
+                                        .udt("ks", "my_udt")
+                                        .withField("a", cassandraTypes.bigint())
+                                        .withField("b", cassandraTypes.text())
+                                        .withField("c", cassandraTypes.inet())
+                                        .withField("d", cassandraTypes.aInt())
+                                        .build());
+        CqlField.CqlType udtType = typeCache.getType("ks", "my_udt");
+        assertEquals("my_udt", udtType.cqlName());
+        assertEquals(17, typeCache.cqlTypeCache.size());
+
+        assertThrows(RuntimeException.class, () -> assertNull(typeCache.getType("ks2", "my_udt")));
+    }
+}
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java
index 0633d12e..2f0e9024 100644
--- a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java
@@ -41,19 +41,19 @@ public interface CommitLog extends Closeable, CassandraFile, Comparable<CommitLo
     // match both legacy and new version of commitlogs Ex: CommitLog-12345.log and CommitLog-6-12345.log.
     Pattern COMMIT_LOG_FILE_PATTERN = Pattern.compile("CommitLog(-(\\d+))?-(\\d+).log");
 
-    static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull final CommitLog log)
+    static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull CommitLog log)
     {
         return extractVersionAndSegmentId(log.name());
     }
 
-    static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull final String filename)
+    static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull String filename)
     {
-        final Matcher matcher = CommitLog.COMMIT_LOG_FILE_PATTERN.matcher(filename);
+        Matcher matcher = CommitLog.COMMIT_LOG_FILE_PATTERN.matcher(filename);
         if (matcher.matches())
         {
             try
             {
-                final int version = matcher.group(2) == null ? 6 : Integer.parseInt(matcher.group(2));
+                int version = matcher.group(2) == null ? 6 : Integer.parseInt(matcher.group(2));
                 if (version != 6 && version != 7)
                 {
                     throw new IllegalStateException("Unknown commitlog version " + version);
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java
index d5d9eb4e..c3ebac7f 100644
--- a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java
@@ -59,7 +59,7 @@ public interface CommitLogMarkers extends Serializable
      */
     boolean canIgnore(Marker position, BigInteger token);
 
-    static PerInstanceCommitLogMarkers of(@Nullable final Marker marker)
+    static PerInstanceCommitLogMarkers of(@Nullable Marker marker)
     {
         if (marker == null)
         {
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/KeyspaceTypeKey.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/KeyspaceTypeKey.java
new file mode 100644
index 00000000..f2664a78
--- /dev/null
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/KeyspaceTypeKey.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.api;
+
+import java.util.Objects;
+
+public class KeyspaceTypeKey
+{
+    public final String keyspace;
+    public final String type;
+
+    public KeyspaceTypeKey(String keyspace, String type)
+    {
+        this.keyspace = keyspace;
+        this.type = type;
+    }
+
+    public static KeyspaceTypeKey of(String keyspace, String type)
+    {
+        return new KeyspaceTypeKey(keyspace, type);
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (this == o)
+        {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass())
+        {
+            return false;
+        }
+        KeyspaceTypeKey that = (KeyspaceTypeKey) o;
+        return keyspace.equals(that.keyspace) && type.equals(that.type);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return Objects.hash(keyspace, type);
+    }
+
+    @Override
+    public String toString()
+    {
+        return "KeyspaceTypeKey{" +
+               "keyspace='" + keyspace + '\'' +
+               ", type='" + type + '\'' +
+               '}';
+    }
+}
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java
index 0a2f8126..10a8bf3b 100644
--- a/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java
@@ -19,11 +19,15 @@
 
 package org.apache.cassandra.spark.utils;
 
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Supplier;
 
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
@@ -46,6 +50,24 @@ public interface AsyncExecutor
 
     <T> CompletableFuture<Void> schedule(Runnable action, long delayMillis);
 
+    /**
+     * Set a periodic timer to fire every delay milliseconds with initial delay, at which point handler will be called with the id of the timer.
+     *
+     * @param action      runnable action to execute every `delayMillis`
+     * @param delayMillis the delay in milliseconds, after which the timer will fire
+     * @return unique timer id
+     */
+    long periodicTimer(Runnable action, long delayMillis);
+
+    /**
+     * Cancels the timer with the specified id.
+     * true if the timer was successfully cancelled, or false if the timer does not exist.
+     *
+     * @param timerId The id of the timer to cancel
+     * @return true if the timer was successfully cancelled, or false if the timer does not exist.
+     */
+    boolean cancelTimer(long timerId);
+
     static AsyncExecutor wrap(ExecutorService executorService)
     {
         return new ExecutorServiceBased(executorService);
@@ -53,6 +75,8 @@ public interface AsyncExecutor
 
     class ExecutorServiceBased implements AsyncExecutor
     {
+        private final AtomicLong timerIds = new AtomicLong(0L);
+        private final Map<Long, ScheduledFuture<?>> timerTasks = new ConcurrentHashMap<>();
         private static final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1,
                                                                                                    new ThreadFactoryBuilder()
                                                                                                    .setNameFormat("scheduler-%d")
@@ -94,5 +118,28 @@ public interface AsyncExecutor
             }, delayMillis, TimeUnit.MILLISECONDS);
             return future;
         }
+
+        @Override
+        public long periodicTimer(Runnable action, long delayMillis)
+        {
+            long timerId = timerIds.getAndIncrement();
+            ScheduledFuture<?> future = SCHEDULER.scheduleAtFixedRate(action, delayMillis, delayMillis, TimeUnit.MILLISECONDS);
+            if (timerTasks.put(timerId, future) != null)
+            {
+                throw new IllegalStateException("Duplicate timerId: " + timerId);
+            }
+            return timerId;
+        }
+
+        @Override
+        public boolean cancelTimer(long timerId)
+        {
+            ScheduledFuture<?> future = timerTasks.get(timerId);
+            if (future != null)
+            {
+                return future.cancel(true);
+            }
+            return false;
+        }
     }
 }
diff --git a/cassandra-analytics-core/build.gradle b/cassandra-analytics-core/build.gradle
index 0ead5528..a44519c5 100644
--- a/cassandra-analytics-core/build.gradle
+++ b/cassandra-analytics-core/build.gradle
@@ -65,6 +65,7 @@ dependencies {
     api(project(':cassandra-bridge'))
 
     implementation project(":cassandra-analytics-common")
+    implementation project(":cassandra-analytics-sidecar-client")
     fourzero(project(path: ':cassandra-four-zero', configuration: 'shadow'))
     fourzerobridge(project(path: ':cassandra-four-zero-bridge'))
     fourzerotypes(project(path: ':cassandra-four-zero-types'))
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/AnalyticsSidecarClient.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/AnalyticsSidecarClient.java
new file mode 100644
index 00000000..d3d248d4
--- /dev/null
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/AnalyticsSidecarClient.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.clients;
+
+import o.a.c.sidecar.client.shaded.io.vertx.core.Vertx;
+import o.a.c.sidecar.client.shaded.io.vertx.core.VertxOptions;
+import org.apache.cassandra.sidecar.client.HttpClientConfig;
+import org.apache.cassandra.sidecar.client.SidecarClient;
+import org.apache.cassandra.sidecar.client.SidecarClientConfig;
+import org.apache.cassandra.sidecar.client.SidecarClientConfigImpl;
+import org.apache.cassandra.sidecar.client.SidecarInstancesProvider;
+import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
+import org.apache.cassandra.spark.bulkwriter.DataTransport;
+import org.apache.cassandra.spark.utils.BuildInfo;
+import org.apache.cassandra.spark.validation.BulkWriterKeyStoreValidation;
+import org.apache.cassandra.spark.validation.BulkWriterTrustStoreValidation;
+import org.apache.cassandra.spark.validation.SslValidation;
+import org.apache.cassandra.spark.validation.StartupValidator;
+
+public class AnalyticsSidecarClient
+{
+    private AnalyticsSidecarClient()
+    {
+    }
+
+    public static SidecarClient from(SidecarInstancesProvider sidecarInstancesProvider, BulkSparkConf conf)
+    {
+        Vertx vertx = Vertx.vertx(new VertxOptions().setUseDaemonThread(true)
+                                                    .setWorkerPoolSize(conf.getMaxHttpConnections()));
+
+        String userAgent = transportModeBasedWriterUserAgent(conf.getTransportInfo().getTransport());
+        HttpClientConfig httpClientConfig = new HttpClientConfig.Builder<>()
+                                            .timeoutMillis(conf.getHttpResponseTimeoutMs())
+                                            .idleTimeoutMillis(conf.getHttpConnectionTimeoutMs())
+                                            .userAgent(userAgent)
+                                            .keyStoreInputStream(conf.getKeyStore())
+                                            .keyStorePassword(conf.getKeyStorePassword())
+                                            .keyStoreType(conf.getKeyStoreTypeOrDefault())
+                                            .trustStoreInputStream(conf.getTrustStore())
+                                            .trustStorePassword(conf.getTrustStorePasswordOrDefault())
+                                            .trustStoreType(conf.getTrustStoreTypeOrDefault())
+                                            .ssl(conf.hasKeystoreAndKeystorePassword())
+                                            .build();
+
+        StartupValidator.instance().register(new SslValidation(conf));
+        StartupValidator.instance().register(new BulkWriterKeyStoreValidation(conf));
+        StartupValidator.instance().register(new BulkWriterTrustStoreValidation(conf));
+
+        SidecarClientConfig sidecarConfig =
+        SidecarClientConfigImpl.builder()
+                               .maxRetries(conf.getSidecarRequestRetries())
+                               .retryDelayMillis(conf.getSidecarRequestRetryDelayMillis())
+                               .maxRetryDelayMillis(conf.getSidecarRequestMaxRetryDelayMillis())
+                               .build();
+
+        return Sidecar.buildClient(sidecarConfig, vertx, httpClientConfig, sidecarInstancesProvider);
+    }
+
+    static String transportModeBasedWriterUserAgent(DataTransport transport)
+    {
+        switch (transport)
+        {
+            case S3_COMPAT:
+                return BuildInfo.WRITER_S3_USER_AGENT;
+            case DIRECT:
+            default:
+                return BuildInfo.WRITER_USER_AGENT;
+        }
+    }
+}
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java
index b5d6fd10..d67981c1 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java
@@ -27,7 +27,7 @@ import com.google.common.base.Preconditions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.clients.AnalyticsSidecarClient;
 import org.apache.cassandra.sidecar.client.SidecarClient;
 import org.apache.cassandra.sidecar.client.SidecarInstance;
 import org.apache.cassandra.sidecar.client.SimpleSidecarInstancesProvider;
@@ -87,7 +87,7 @@ public class CassandraContext implements StartupValidatable, Closeable
 
     protected SidecarClient initializeSidecarClient(BulkSparkConf conf)
     {
-        return Sidecar.from(new SimpleSidecarInstancesProvider(new ArrayList<>(clusterConfig)), conf);
+        return AnalyticsSidecarClient.from(new SimpleSidecarInstancesProvider(new ArrayList<>(clusterConfig)), conf);
     }
 
     protected Set<SidecarInstance> createClusterConfig()
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterKeyStoreValidation.java
similarity index 62%
copy from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
copy to cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterKeyStoreValidation.java
index 3a3c5a82..dd01eff9 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterKeyStoreValidation.java
@@ -19,24 +19,18 @@
 
 package org.apache.cassandra.spark.validation;
 
-/**
- * An interface that has to be implemented by all startup validations
- */
-@FunctionalInterface
-public interface StartupValidation
-{
-    void validate();
+import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
+import org.jetbrains.annotations.NotNull;
 
-    default Throwable perform()
+public class BulkWriterKeyStoreValidation extends KeyStoreValidation
+{
+    public BulkWriterKeyStoreValidation(@NotNull BulkSparkConf configuration)
     {
-        try
-        {
-            validate();
-        }
-        catch (Throwable throwable)
-        {
-            return throwable;
-        }
-        return null;
+        super(
+        configuration.hasKeystoreAndKeystorePassword(),
+        configuration.getKeyStoreTypeOrDefault(),
+        configuration.getKeyStorePassword() == null ? null : configuration.getKeyStorePassword().toCharArray(),
+        configuration::getKeyStore
+        );
     }
 }
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterTrustStoreValidation.java
similarity index 63%
copy from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
copy to cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterTrustStoreValidation.java
index 3a3c5a82..d9a4643e 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterTrustStoreValidation.java
@@ -19,24 +19,18 @@
 
 package org.apache.cassandra.spark.validation;
 
-/**
- * An interface that has to be implemented by all startup validations
- */
-@FunctionalInterface
-public interface StartupValidation
-{
-    void validate();
+import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
+import org.jetbrains.annotations.NotNull;
 
-    default Throwable perform()
+public class BulkWriterTrustStoreValidation extends TrustStoreValidation
+{
+    public BulkWriterTrustStoreValidation(@NotNull BulkSparkConf configuration)
     {
-        try
-        {
-            validate();
-        }
-        catch (Throwable throwable)
-        {
-            return throwable;
-        }
-        return null;
+        super(
+        configuration.hasTruststoreAndTruststorePassword(),
+        configuration.getTrustStoreTypeOrDefault(),
+        configuration.getTrustStorePasswordOrDefault().toCharArray(),
+        configuration::getTrustStore
+        );
     }
 }
diff --git a/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java b/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java
index bff83f38..54a530a1 100644
--- a/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java
+++ b/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java
@@ -108,10 +108,10 @@ public class SidecarClientConfigTest
     @Test
     public void testTransportModeBasedWriterUserAgent()
     {
-        String userAgentStr = Sidecar.transportModeBasedWriterUserAgent(DataTransport.DIRECT);
+        String userAgentStr = AnalyticsSidecarClient.transportModeBasedWriterUserAgent(DataTransport.DIRECT);
         assertTrue(userAgentStr.endsWith(" writer"));
 
-        userAgentStr = Sidecar.transportModeBasedWriterUserAgent(DataTransport.S3_COMPAT);
+        userAgentStr = AnalyticsSidecarClient.transportModeBasedWriterUserAgent(DataTransport.S3_COMPAT);
         assertTrue(userAgentStr.endsWith(" writer-s3"));
     }
 }
diff --git a/cassandra-analytics-sidecar-client/build.gradle b/cassandra-analytics-sidecar-client/build.gradle
new file mode 100644
index 00000000..1126601b
--- /dev/null
+++ b/cassandra-analytics-sidecar-client/build.gradle
@@ -0,0 +1,65 @@
+import java.nio.file.Paths
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+plugins {
+    id('java-library')
+    id('maven-publish')
+}
+
+configurations {
+    all*.exclude(group: 'org.slf4j', module: 'slf4j-log4j12')
+    all*.exclude(group: 'log4j', module: 'log4j')
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from components.java
+            groupId project.group
+            artifactId "${archivesBaseName}"
+            version System.getenv("CODE_VERSION") ?: "${version}"
+        }
+    }
+}
+
+configurations {
+    fourzero {
+        description = 'Cassandra 4.0 dependency'
+    }
+    fourzerobridge {
+        description = 'Bridge to Cassandra 4.0'
+    }
+    fourzerotypes {
+        description = 'Cassandra 4.0 Data Types'
+    }
+}
+
+dependencies {
+    api(project(':cassandra-bridge'))
+
+    compileOnly("com.google.guava:guava:${guavaVersion}")
+    implementation project(":cassandra-analytics-common")
+
+    implementation "org.slf4j:slf4j-api:${slf4jApiVersion}"
+
+    // This dependency must be built by running `scripts/build-dependencies.sh`
+    api(group: "${sidecarClientGroup}", name: "${sidecarClientName}", version: "${sidecarVersion}")
+}
\ No newline at end of file
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/Sidecar.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/Sidecar.java
similarity index 86%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/Sidecar.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/Sidecar.java
index fee81161..c0de9c7b 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/Sidecar.java
+++ b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/Sidecar.java
@@ -47,14 +47,11 @@ import org.apache.cassandra.sidecar.client.VertxHttpClient;
 import org.apache.cassandra.sidecar.client.VertxRequestExecutor;
 import org.apache.cassandra.sidecar.client.retry.ExponentialBackoffRetryPolicy;
 import org.apache.cassandra.sidecar.client.retry.RetryPolicy;
-import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
-import org.apache.cassandra.spark.bulkwriter.DataTransport;
 import org.apache.cassandra.spark.common.model.CassandraInstance;
 import org.apache.cassandra.spark.data.FileType;
 import org.apache.cassandra.spark.utils.BuildInfo;
 import org.apache.cassandra.spark.utils.MapUtils;
 import org.apache.cassandra.spark.validation.KeyStoreValidation;
-import org.apache.cassandra.spark.validation.SslValidation;
 import org.apache.cassandra.spark.validation.StartupValidator;
 import org.apache.cassandra.spark.validation.TrustStoreValidation;
 
@@ -122,51 +119,6 @@ public final class Sidecar
         return buildClient(sidecarConfig, vertx, httpClientConfig, sidecarInstancesProvider);
     }
 
-    static String transportModeBasedWriterUserAgent(DataTransport transport)
-    {
-        switch (transport)
-        {
-            case S3_COMPAT:
-                return BuildInfo.WRITER_S3_USER_AGENT;
-            case DIRECT:
-            default:
-                return BuildInfo.WRITER_USER_AGENT;
-        }
-    }
-
-    public static SidecarClient from(SidecarInstancesProvider sidecarInstancesProvider, BulkSparkConf conf)
-    {
-        Vertx vertx = Vertx.vertx(new VertxOptions().setUseDaemonThread(true)
-                                                    .setWorkerPoolSize(conf.getMaxHttpConnections()));
-
-        String userAgent = transportModeBasedWriterUserAgent(conf.getTransportInfo().getTransport());
-        HttpClientConfig httpClientConfig = new HttpClientConfig.Builder<>()
-                                            .timeoutMillis(conf.getHttpResponseTimeoutMs())
-                                            .idleTimeoutMillis(conf.getHttpConnectionTimeoutMs())
-                                            .userAgent(userAgent)
-                                            .keyStoreInputStream(conf.getKeyStore())
-                                            .keyStorePassword(conf.getKeyStorePassword())
-                                            .keyStoreType(conf.getKeyStoreTypeOrDefault())
-                                            .trustStoreInputStream(conf.getTrustStore())
-                                            .trustStorePassword(conf.getTrustStorePasswordOrDefault())
-                                            .trustStoreType(conf.getTrustStoreTypeOrDefault())
-                                            .ssl(conf.hasKeystoreAndKeystorePassword())
-                                            .build();
-
-        StartupValidator.instance().register(new SslValidation(conf));
-        StartupValidator.instance().register(new KeyStoreValidation(conf));
-        StartupValidator.instance().register(new TrustStoreValidation(conf));
-
-        SidecarClientConfig sidecarConfig =
-        SidecarClientConfigImpl.builder()
-                               .maxRetries(conf.getSidecarRequestRetries())
-                               .retryDelayMillis(conf.getSidecarRequestRetryDelayMillis())
-                               .maxRetryDelayMillis(conf.getSidecarRequestMaxRetryDelayMillis())
-                               .build();
-
-        return buildClient(sidecarConfig, vertx, httpClientConfig, sidecarInstancesProvider);
-    }
-
     public static SidecarClient buildClient(SidecarClientConfig sidecarConfig,
                                             Vertx vertx,
                                             HttpClientConfig httpClientConfig,
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
similarity index 85%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
index 1e80e17a..cf68ca88 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
+++ b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
@@ -32,7 +32,6 @@ import java.util.Enumeration;
 import java.util.function.Supplier;
 
 import org.apache.cassandra.secrets.SecretsProvider;
-import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
 import org.apache.cassandra.spark.utils.Throwing;
 import org.jetbrains.annotations.NotNull;
 
@@ -48,18 +47,23 @@ public class KeyStoreValidation implements StartupValidation
 
     public KeyStoreValidation(@NotNull SecretsProvider secrets)
     {
-        configured = secrets.hasKeyStoreSecrets();
-        type = secrets.keyStoreType();
-        password = secrets.keyStorePassword();
-        stream = Throwing.supplier(secrets::keyStoreInputStream);
+        this(
+        secrets.hasKeyStoreSecrets(),
+        secrets.keyStoreType(),
+        secrets.keyStorePassword(),
+        Throwing.supplier(secrets::keyStoreInputStream)
+        );
     }
 
-    public KeyStoreValidation(@NotNull BulkSparkConf configuration)
+    protected KeyStoreValidation(boolean configured,
+                                 String type,
+                                 char[] password,
+                                 Supplier<InputStream> stream)
     {
-        configured = configuration.hasKeystoreAndKeystorePassword();
-        type = configuration.getKeyStoreTypeOrDefault();
-        password = configuration.getKeyStorePassword() == null ? null : configuration.getKeyStorePassword().toCharArray();
-        stream = configuration::getKeyStore;
+        this.configured = configured;
+        this.type = type;
+        this.password = password;
+        this.stream = stream;
     }
 
     @Override
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
similarity index 81%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
index ab4fec0f..80f7f3b2 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
+++ b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
@@ -28,7 +28,6 @@ import java.util.Enumeration;
 import java.util.function.Supplier;
 
 import org.apache.cassandra.secrets.SecretsProvider;
-import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
 import org.apache.cassandra.spark.utils.Throwing;
 import org.jetbrains.annotations.NotNull;
 
@@ -44,18 +43,23 @@ public class TrustStoreValidation implements StartupValidation
 
     public TrustStoreValidation(@NotNull SecretsProvider secrets)
     {
-        configured = secrets.hasTrustStoreSecrets();
-        type = secrets.trustStoreType();
-        password = secrets.trustStorePassword();
-        stream = Throwing.supplier(() -> secrets.trustStoreInputStream());
+        this(
+        secrets.hasTrustStoreSecrets(),
+        secrets.trustStoreType(),
+        secrets.trustStorePassword(),
+        Throwing.supplier(secrets::trustStoreInputStream)
+        );
     }
 
-    public TrustStoreValidation(@NotNull BulkSparkConf configuration)
+    protected TrustStoreValidation(boolean configured,
+                                   String type,
+                                   char[] password,
+                                   Supplier<InputStream> stream)
     {
-        configured = configuration.hasTruststoreAndTruststorePassword();
-        type = configuration.getTrustStoreTypeOrDefault();
-        password = configuration.getTrustStorePasswordOrDefault().toCharArray();
-        stream = () -> configuration.getTrustStore();
+        this.configured = configured;
+        this.type = type;
+        this.password = password;
+        this.stream = stream;
     }
 
     @Override
diff --git a/gradle.properties b/gradle.properties
index 6fc08a53..5c792e7f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -38,6 +38,7 @@ guavaVersion=16.0.1
 vertxVersion=4.5.1
 aswSdkVersion=2.26.12
 commonsLang3Version=3.12.0
+cassandraDriverVersion=3.11.3
 
 org.gradle.jvmargs=-Xmx4096m
 
diff --git a/settings.gradle b/settings.gradle
index 21e19654..5feed863 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -20,6 +20,7 @@
 rootProject.name = 'cassandra-analytics-core'
 
 include 'cassandra-analytics-cdc'
+include 'cassandra-analytics-cdc-sidecar'
 include 'cassandra-analytics-common'
 include 'cassandra-bridge'
 include 'cassandra-four-zero'
@@ -29,6 +30,7 @@ include 'cassandra-analytics-core'
 include 'cassandra-analytics-core-example'
 include 'cassandra-analytics-integration-framework'
 include 'cassandra-analytics-integration-tests'
+include 'cassandra-analytics-sidecar-client'
 include 'cassandra-analytics-spark-converter'
 include 'cassandra-analytics-spark-four-zero-converter'
 include 'cassandra-analytics-cdc-codec'


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org