Bump org.apache.logging.log4j:log4j-core from 2.20.0 to 2.24.3

Bumps org.apache.logging.log4j:log4j-core from 2.20.0 to 2.24.3. --- updated-dependencies: - dependency-name: org.apache.logging.log4j:log4j-core dependency-type: direct:development update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
Reintroduce snapshot version (#1377 )
2024-12-16 13:40:24 +00:00 · 2024-08-16 13:39:19 -07:00 · 2024-08-15 10:57:09 -07:00 · 2024-07-25 17:01:27 -07:00 · 2024-06-07 12:49:10 -07:00 · 2024-06-07 12:43:01 -07:00
260 changed files with 13169 additions and 7602 deletions
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@ -0,0 +1,32 @@
+# This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Java CI with Maven
+
+on:
+  push:
+    branches:
+      - 'v1.x'
+  pull_request:
+    branches:
+      - 'v1.x'
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 8
+        uses: actions/setup-java@v3
+        with:
+          java-version: '8'
+          distribution: 'corretto'
+      - name: Build with Maven
+        run: mvn -B package --file pom.xml -DskipITs
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,4 +1,213 @@
 # Changelog
+### Latest Release (1.15.2 - Aug 14, 2024)
+* [#1371](https://github.com/awslabs/amazon-kinesis-client/pull/1371) Fix a bug in debug and trace logging levels for worker
+* [#1224](https://github.com/awslabs/amazon-kinesis-client/pull/1224) Modify RecordProcessorCheckpointer#advancePosition Metrics usage to ensure proper closure
+* [#1345](https://github.com/awslabs/amazon-kinesis-client/pull/1345) Generate wrappers from proto files instead of shipping them directly
+* [#1346](https://github.com/awslabs/amazon-kinesis-client/pull/1346) Upgrade com.google.protobuf:protobuf-java from 3.23.4 to 4.27.1
+* [#1338](https://github.com/awslabs/amazon-kinesis-client/pull/1338) Upgrade org.apache.logging.log4j:log4j-api from 2.20.0 to 2.23.1
+* [#1327](https://github.com/awslabs/amazon-kinesis-client/pull/1327) Upgrade com.google.guava:guava from 33.0.0-jre to 33.2.0-jre 
+* [#1283](https://github.com/awslabs/amazon-kinesis-client/pull/1283) Upgrade com.fasterxml.jackson.core:jackson-core from 2.15.2 to 2.17.0
+* [#1284](https://github.com/awslabs/amazon-kinesis-client/pull/1284) Upgrade aws-java-sdk.version from 1.12.647 to 1.12.681
+* [#1288](https://github.com/awslabs/amazon-kinesis-client/pull/1288) Upgrade commons-logging:commons-logging from 1.2 to 1.3.1
+* [#1289](https://github.com/awslabs/amazon-kinesis-client/pull/1289) Upgrade org.projectlombok:lombok from 1.18.22 to 1.18.32
+* [#1248](https://github.com/awslabs/amazon-kinesis-client/pull/1248) Upgrade org.apache.maven.plugins:maven-surefire-plugin from 2.22.2 to 3.2.5
+* [#1234](https://github.com/awslabs/amazon-kinesis-client/pull/1234) Upgrade org.apache.maven.plugins:maven-javadoc-plugin from 3.4.1 to 3.6.3
+* [#1137](https://github.com/awslabs/amazon-kinesis-client/pull/1137) Upgrade maven-failsafe-plugin from 2.22.2 to 3.1.2
+* [#1134](https://github.com/awslabs/amazon-kinesis-client/pull/1134) Upgrade jackson-core from 2.15.0 to 2.15.2
+* [#1119](https://github.com/awslabs/amazon-kinesis-client/pull/1119) Upgrade maven-source-plugin from 3.2.1 to 3.3.0
+* [#1165](https://github.com/awslabs/amazon-kinesis-client/pull/1165) Upgrade protobuf-java from 3.19.6 to 3.23.4
+
+### Release (1.15.1 - Feb 5, 2023)
+* [#1214](https://github.com/awslabs/amazon-kinesis-client/pull/1214) Added backoff logic for ShardSyncTaskIntegrationTest
+* [#1214](https://github.com/awslabs/amazon-kinesis-client/pull/1214) Upgrade Guava version from 31.0.1 to 32.1.1
+* [#1252](https://github.com/awslabs/amazon-kinesis-client/pull/1252) Upgrade aws-java-sdk from 1.12.406 to 1.12.647
+
+### Release (1.15.0 - Jun 8, 2023)
+* **[#1108](https://github.com/awslabs/amazon-kinesis-client/pull/1108) Add support for Stream ARNs**
+* [#1111](https://github.com/awslabs/amazon-kinesis-client/pull/1111) More consistent testing behavior with HashRangesAreAlwaysComplete
+* [#1054](https://github.com/awslabs/amazon-kinesis-client/pull/1054) Upgrade log4j-core from 2.17.1 to 2.20.0
+* [#1103](https://github.com/awslabs/amazon-kinesis-client/pull/1103) Upgrade jackson-core from 2.13.0 to 2.15.0
+* [#943](https://github.com/awslabs/amazon-kinesis-client/pull/943) Upgrade nexus-staging-maven-plugin from 1.6.8 to 1.6.13
+* [#1044](https://github.com/awslabs/amazon-kinesis-client/pull/1044) Upgrade aws-java-sdk.version from 1.12.406 to 1.12.408
+* [#1055](https://github.com/awslabs/amazon-kinesis-client/pull/1055) Upgrade maven-compiler-plugin from 3.10.0 to 3.11.0
+
+### Release (1.14.10 - Feb 15, 2023)
+* Updated aws-java-sdk from 1.12.130 to 1.12.406 
+* Updated com.google.protobuf from 3.19.4 to 3.19.6
+  * [Issue #1026](https://github.com/awslabs/amazon-kinesis-client/issues/1026)
+  * [PR #1042](https://github.com/awslabs/amazon-kinesis-client/pull/1042)
+
+### Release (1.14.9 - Dec 14, 2022)
+* [#995](https://github.com/awslabs/amazon-kinesis-client/commit/372f98b21a91487e36612d528c56765a44b0aa86) Every other change for DynamoDBStreamsKinesis Adapter Compatibility
+* [#970](https://github.com/awslabs/amazon-kinesis-client/commit/251b331a2e0fd912b50f8b5a12d088bf0b3263b9) PeriodicShardSyncManager Changes Needed for DynamoDBStreamsKinesisAdapter
+
+### Release (1.14.8 - Feb 24, 2022)
+* [Bump log4j-core from 2.17.0 to 2.17.1](https://github.com/awslabs/amazon-kinesis-client/commit/94b138a9d9a502ee0f4f000bb0efd2766ebadc37)
+* [Bump protobuf-java from 3.19.1 to 3.19.4](https://github.com/awslabs/amazon-kinesis-client/commit/a809b12c43c57a3d6ad3827feb60e4322614259c)
+* [Bump maven-compiler-plugin from 3.8.1 to 3.10.0](https://github.com/awslabs/amazon-kinesis-client/commit/37b5d7b9a1ccad483469ef542a6a7237462b14f2)
+
+### Release (1.14.7 - Dec 22, 2021)
+* [#881](https://github.com/awslabs/amazon-kinesis-client/pull/881) Update log4j test dependency from 2.16.0 to 2.17.0 and some other dependencies
+
+### Release (1.14.6 - Dec 15, 2021)
+* [#876](https://github.com/awslabs/amazon-kinesis-client/pull/876) Update log4j test dependency from 2.15.0 to 2.16.0
+
+### Release (1.14.5 - Dec 10, 2021)
+* [#872](https://github.com/awslabs/amazon-kinesis-client/pull/872) Update log4j test dependency from 1.2.17 to 2.15.0
+* [#873](https://github.com/awslabs/amazon-kinesis-client/pull/873) Upgrading version of AWS Java SDK to 1.12.128
+
+### Release (1.14.4 - June 14, 2021)
+* [Milestone#61](https://github.com/awslabs/amazon-kinesis-client/milestone/61)
+* [#816](https://github.com/awslabs/amazon-kinesis-client/pull/816) Updated the Worker shutdown logic to make sure that the `LeaseCleanupManager` also terminates all the threads that it has started.
+* [#821](https://github.com/awslabs/amazon-kinesis-client/pull/821) Upgrading version of AWS Java SDK to 1.12.3
+
+### Release (1.14.3 - May 3, 2021)
+* [Milestone#60](https://github.com/awslabs/amazon-kinesis-client/milestone/60)
+* [#811](https://github.com/awslabs/amazon-kinesis-client/pull/811) Fixing a bug in `KinesisProxy` that can lead to undetermined behavior during partial failures.
+* [#811](https://github.com/awslabs/amazon-kinesis-client/pull/811) Adding guardrails to handle duplicate shards from the service.
+
+## Release (1.14.2 - February 24, 2021)
+* [Milestone#57](https://github.com/awslabs/amazon-kinesis-client/milestone/57)
+* [#790](https://github.com/awslabs/amazon-kinesis-client/pull/790) Fixing a bug that caused paginated `ListShards` calls with the `ShardFilter` parameter to fail when the lease table was being initialized.
+
+## Release (1.14.1 - January 27, 2021)
+* [Milestone#56](https://github.com/awslabs/amazon-kinesis-client/milestone/56)
+
+* Fix for cross DDB table interference when multiple KCL applications are run in same JVM.
+* Fix and guards to avoid potential checkpoint rewind during shard end, which may block children shard processing.
+* Fix for thread cycle wastage on InitializeTask for deleted shard.
+* Improved logging in LeaseCleanupManager that would indicate why certain shards are not cleaned up from the lease table.
+
+
+## Release (1.14.0 - August 17, 2020)
+
+* [Milestone#50](https://github.com/awslabs/amazon-kinesis-client/milestone/50)
+
+* Behavior of shard synchronization is moving from each worker independently learning about all existing shards to workers only discovering the children of shards that each worker owns. This optimizes memory usage, lease table IOPS usage, and number of calls made to kinesis for streams with high shard counts and/or frequent resharding.
+* When bootstrapping an empty lease table, KCL utilizes the ListShard API's filtering option (the ShardFilter optional request parameter) to retrieve and create leases only for a snapshot of shards open at the time specified by the ShardFilter parameter. The ShardFilter parameter enables you to filter out the response of the ListShards API, using the Type parameter. KCL uses the Type filter parameter and the following of its valid values to identify and return a snapshot of open shards that might require new leases.
+	* Currently, the following shard filters are supported:
+		* `AT_TRIM_HORIZON` - the response includes all the shards that were open at `TRIM_HORIZON`.
+		* `AT_LATEST` - the response includes only the currently open shards of the data stream.
+	    * `AT_TIMESTAMP` - the response includes all shards whose start timestamp is less than or equal to the given timestamp and end timestamp is greater than or equal to the given timestamp or still open.
+	* `ShardFilter` is used when creating leases for an empty lease table to initialize leases for a snapshot of shards specified at `KinesisClientLibConfiguration#initialPositionInStreamExtended`.
+	* For more information about ShardFilter, see the [official AWS documentation on ShardFilter](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ShardFilter.html).
+
+* Introducing support for the `ChildShards` response of the `GetRecords` API to perform lease/shard synchronization that happens at `SHARD_END` for closed shards, allowing a KCL worker to only create leases for the child shards of the shard it finished processing.
+	* For KCL 1.x applications, this uses the `ChildShards` response of the `GetRecords` API.
+	* For more information, see the official AWS Documentation on [GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html) and [ChildShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ChildShard.html).
+
+* KCL now also performs additional periodic shard/lease scans in order to identify any potential holes in the lease table to ensure the complete hash range of the stream is being processed and create leases for them if required. When `KinesisClientLibConfiguration#shardSyncStrategyType` is set to `ShardSyncStrategyType.SHARD_END`, `PeriodicShardSyncManager#leasesRecoveryAuditorInconsistencyConfidenceThreshold` will be used to determine the threshold for number of consecutive scans containing holes in the lease table after which to enforce a shard sync. When `KinesisClientLibConfiguration#shardSyncStrategyType` is set to `ShardSyncStrategyType.PERIODIC`, `leasesRecoveryAuditorInconsistencyConfidenceThreshold` is ignored.
+	* New configuration options are available to configure `PeriodicShardSyncManager` in `KinesisClientLibConfiguration`
+
+	| Name                                                  | Default | Description                                                                                                                                                                                                                                                                                       |
+	| ----------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+	| leasesRecoveryAuditorInconsistencyConfidenceThreshold | 3       | Confidence threshold for the periodic auditor job to determine if leases for a stream in the lease table is inconsistent. If the auditor finds same set of inconsistencies consecutively for a stream for this many times, then it would trigger a shard sync. Only used for `ShardSyncStrategyType.SHARD_END`. |
+
+	* New CloudWatch metrics are also now emitted to monitor the health of `PeriodicShardSyncManager`:
+
+	| Name                        | Description                                            |
+	| --------------------------- | ------------------------------------------------------ |
+	| NumStreamsWithPartialLeases | Number of streams that had holes in their hash ranges. |
+	| NumStreamsToSync            | Number of streams which underwent a full shard sync.   |
+
+* Introducing deferred lease cleanup. Leases will be deleted asynchronously by `LeaseCleanupManager` upon reaching `SHARD_END`, when a shard has either expired past the stream’s retention period or been closed as the result of a resharding operation.
+	* New configuration options are available to configure `LeaseCleanupManager`.
+
+	| Name                                | Default    | Description                                                                                               |
+	| ----------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------- |
+	| leaseCleanupIntervalMillis          | 1 minute   | Interval at which to run lease cleanup thread.                                                            |
+	| completedLeaseCleanupIntervalMillis | 5 minutes  | Interval at which to check if a lease is completed or not.                                                |
+	| garbageLeaseCleanupIntervalMillis   | 30 minutes | Interval at which to check if a lease is garbage (i.e trimmed past the stream's retention period) or not. |
+
+* Including an optimization to `KinesisShardSyncer` to only create leases for one layer of shards.
+* Changing default shard prioritization strategy to be `NoOpShardPrioritization` to allow prioritization of completed shards. Customers who are upgrading to this version and are reading from `TRIM_HORIZON` should continue using `ParentsFirstShardPrioritization` while upgrading.
+* Upgrading version of AWS SDK to 1.11.844.
+* [#719](https://github.com/awslabs/amazon-kinesis-client/pull/719) Upgrading version of Google Protobuf to 3.11.4.
+* [#712](https://github.com/awslabs/amazon-kinesis-client/pull/712) Allowing KCL to consider lease tables in `UPDATING` healthy.
+
+## Release 1.13.3 (1.13.3 March 2, 2020)
+[Milestone#49] (https://github.com/awslabs/amazon-kinesis-client/milestone/49）
+* Refactoring shard closure verification performed by ShutdownTask.
+  * [PR #684] (https://github.com/awslabs/amazon-kinesis-client/pull/684)
+* Fixing the bug in ShardSyncTaskManager to resolve the issue of new shards not being processed after resharding.
+  * [PR #694] (https://github.com/awslabs/amazon-kinesis-client/pull/694)
+
+## Release 1.13.2 （Janurary 13, 2020）
+* Adding backward compatible constructors that use the default DDB Billing Mode (#673)
+  * [PR #673](https://github.com/awslabs/amazon-kinesis-client/pull/673)
+
+## Release 1.13.1 (December 31, 2019)
+[Milestone#44](https://github.com/awslabs/amazon-kinesis-client/milestone/44)
+* Adding BillingMode Support to KCL 1.x. This enables the customer to specify if they want provisioned capacity for DDB, or pay per request.
+  * [PR #656](https://github.com/awslabs/amazon-kinesis-client/pull/656)
+* Ensure ShardSyncTask invocation from ShardSyncTaskManager for pending ShardEnd events.
+  * [PR #659](https://github.com/awslabs/amazon-kinesis-client/pull/659)
+* Fix the LeaseManagementIntegrationTest failure.
+  * [PR #670](https://github.com/awslabs/amazon-kinesis-client/pull/670)
+
+## Release 1.13.0 (November 5, 2019)
+[Milestone#42](https://github.com/awslabs/amazon-kinesis-client/milestone/42)
+* Handling completed and blocked tasks better during graceful shutdown
+  * [PR #640](https://github.com/awslabs/amazon-kinesis-client/pull/640)
+
+## Release 1.12.0 (October 17, 2019)
+[Milestone#41](https://github.com/awslabs/amazon-kinesis-client/milestone/41)
+* Adding logging around shard end codepaths.
+  * [PR #585](https://github.com/awslabs/amazon-kinesis-client/pull/585)
+* Updating checkpointing failure message to refer to javadocs.
+  * [PR #590](https://github.com/awslabs/amazon-kinesis-client/pull/590)
+* Updating Sonatype to dedicated AWS endpoint.
+  * [PR #618](https://github.com/awslabs/amazon-kinesis-client/pull/618)
+* Introducing a validation step to verify if ShardEnd is reached, to prevent shard consumer stuck scenarios in the event of malformed response from service.
+  * [PR #623](https://github.com/awslabs/amazon-kinesis-client/pull/623)
+* Updating AWS SDK to 1.11.655
+  * [PR #626](https://github.com/awslabs/amazon-kinesis-client/pull/626)
+
+## Release 1.11.2 (August 15, 2019)
+[Milestone#35](https://github.com/awslabs/amazon-kinesis-client/milestone/35)
+* Added support for metrics emission in `PeriodicShardSyncer`.
+  * [PR #592](https://github.com/awslabs/amazon-kinesis-client/pull/592)
+
+## Release 1.11.1 (August 9, 2019)
+[Milestone#34](https://github.com/awslabs/amazon-kinesis-client/milestone/34)
+* Updated the version of the AWS Java SDK to 1.11.603.
+  * [PR #587](https://github.com/awslabs/amazon-kinesis-client/pull/587)
+* Added logging to `KinesisDataFetcher` when reaching the end of a shard due to a null next iterator.
+  * [PR #585](https://github.com/awslabs/amazon-kinesis-client/pull/585)
+
+## Release 1.11.0 (August 7, 2019)
+[Milestone#33](https://github.com/awslabs/amazon-kinesis-client/milestone/33)
+* Improved exception handling and logging in `KinesisClientLibLeaseCoordinator` to avoid `NullPointerExceptions` when no leases are found.
+  * [PR #558](https://github.com/awslabs/amazon-kinesis-client/pull/558)
+* Introducing optional new periodic shard sync strategy to perform shard discovery and lease cleanup on a single worker.
+  * [PR #579](https://github.com/awslabs/amazon-kinesis-client/pull/579)
+
+## Release 1.10.0 (April 8, 2019)
+[Milestone#31](https://github.com/awslabs/amazon-kinesis-client/milestone/31)
+* Updated License to [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+  * [PR#522](https://github.com/awslabs/amazon-kinesis-client/pull/522)	
+## Release 1.9.3 (October 30, 2018)
+* Upgraded Apache Commons Lang from 2.6 to 3.7.  
+  * [Issue #370](https://github.com/awslabs/amazon-kinesis-client/issues/370)
+  * [PR #406](https://github.com/awslabs/amazon-kinesis-client/pull/406)
+* Upgraded Google Guava from 10.0 to 26.0-jre.  
+  * [Issue #416](https://github.com/awslabs/amazon-kinesis-client/issues/416)
+  * [PR #421](https://github.com/awslabs/amazon-kinesis-client/pull/421)
+
+## Release 1.9.2 (September 4, 2018)
+* Allow use of Immutable Clients  
+  * [Issue #280](https://github.com/awslabs/amazon-kinesis-client/issues/280)
+  * [PR #305](https://github.com/awslabs/amazon-kinesis-client/pull/305)
+* Allow the use of `AT_TIMESTAMP` for MultiLang Daemon Clients.  
+  * [Issue #341](https://github.com/awslabs/amazon-kinesis-client/issues/341)
+  * [PR #342](https://github.com/awslabs/amazon-kinesis-client/pull/342)
+* Update the cache for `KinesisProxy#getShard` on cache misses.  
+  * [PR #344](https://github.com/awslabs/amazon-kinesis-client/pull/344)
+* Changed release process to use a standard process.  
+  * [PR #389](https://github.com/awslabs/amazon-kinesis-client/pull/389)
+* Removed tests that expected a null region response for unknown regions.  
+  * [PR #346](https://github.com/awslabs/amazon-kinesis-client/pull/346)
+* Updated the version of the AWS Java SDK to 1.11.400  

 ## Release 1.9.1 (April 30, 2018)
 * Added the ability to create a prepared checkpoint when at `SHARD_END`.
--- a/LICENSE.txt
+++ b/LICENSE.txt
@ -1,40 +1,201 @@
+                               Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/

-Amazon Software License
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

-This Amazon Software License (“License”) governs your use, reproduction, and distribution of the accompanying software as specified below.
-1. Definitions
+   1. Definitions.

-“Licensor” means any person or entity that distributes its Work.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.

-“Software” means the original work of authorship made available under this License.
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.

-“Work” means the Software and any additions to or derivative works of the Software that are made available under this License.
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.

-The terms “reproduce,” “reproduction,” “derivative works,” and “distribution” have the meaning as provided under U.S. copyright law; provided, however, that for the purposes of this License, derivative works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work.
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.

-Works, including the Software, are “made available” under this License by including in or with the Work either (a) a copyright notice referencing the applicability of this License to the Work, or (b) a copy of this License.
-2. License Grants
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.

-2.1 Copyright Grant. Subject to the terms and conditions of this License, each Licensor grants to you a perpetual, worldwide, non-exclusive, royalty-free, copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense and distribute its Work and any resulting derivative works in any form.
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.

-2.2 Patent Grant. Subject to the terms and conditions of this License, each Licensor grants to you a perpetual, worldwide, non-exclusive, royalty-free patent license to make, have made, use, sell, offer for sale, import, and otherwise transfer its Work, in whole or in part. The foregoing license applies only to the patent claims licensable by Licensor that would be infringed by Licensor’s Work (or portion thereof) individually and excluding any combinations with any other materials or technology.
-3. Limitations
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).

-3.1 Redistribution. You may reproduce or distribute the Work only if (a) you do so under this License, (b) you include a complete copy of this License with your distribution, and (c) you retain without modification any copyright, patent, trademark, or attribution notices that are present in the Work.
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.

-3.2 Derivative Works. You may specify that additional or different terms apply to the use, reproduction, and distribution of your derivative works of the Work (“Your Terms”) only if (a) Your Terms provide that the use limitation in Section 3.3 applies to your derivative works, and (b) you identify the specific derivative works that are subject to Your Terms. Notwithstanding Your Terms, this License (including the redistribution requirements in Section 3.1) will continue to apply to the Work itself.
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."

-3.3 Use Limitation. The Work and any derivative works thereof only may be used or intended for use with the web services, computing platforms or applications provided by Amazon.com, Inc. or its affiliates, including Amazon Web Services, Inc.
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.

-3.4 Patent Claims. If you bring or threaten to bring a patent claim against any Licensor (including any claim, cross-claim or counterclaim in a lawsuit) to enforce any patents that you allege are infringed by any Work, then your rights under this License from such Licensor (including the grants in Sections 2.1 and 2.2) will terminate immediately.
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.

-3.5 Trademarks. This License does not grant any rights to use any Licensor’s or its affiliates’ names, logos, or trademarks, except as necessary to reproduce the notices described in this License.
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.

-3.6 Termination. If you violate any term of this License, then your rights under this License (including the grants in Sections 2.1 and 2.2) will terminate immediately.
-4. Disclaimer of Warranty.
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:

-THE WORK IS PROVIDED “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF M ERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER THIS LICENSE. SOME STATES’ CONSUMER LAWS DO NOT ALLOW EXCLUSION OF AN IMPLIED WARRANTY, SO THIS DISCLAIMER MAY NOT APPLY TO YOU.
-5. Limitation of Liability.
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and

-EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK (INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER COMM ERCIAL DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and

+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.
--- a/README.md
+++ b/README.md
@ -1,4 +1,8 @@
-# Amazon Kinesis Client Library for Java [![Build Status](https://travis-ci.org/awslabs/amazon-kinesis-client.svg?branch=master)](https://travis-ci.org/awslabs/amazon-kinesis-client)
+# Bugs in 1.14.0 version
+We recommend customers to migrate to 1.14.1 to avoid [known bugs](https://github.com/awslabs/amazon-kinesis-client/issues/778) in 1.14.0 version
+
+# Amazon Kinesis Client Library for Java
+[![Build Status](https://travis-ci.org/awslabs/amazon-kinesis-client.svg?branch=master)](https://travis-ci.org/awslabs/amazon-kinesis-client) ![BuildStatus](https://codebuild.us-west-2.amazonaws.com/badges?uuid=eyJlbmNyeXB0ZWREYXRhIjoiaWo4bDYyUkpWaG9ZTy9zeFVoaVlWbEwxazdicDJLcmZwUUpFWVVBM0ZueEJSeFIzNkhURzdVbUd6WUZHcGNxa3BEUzNrL0I5Nzc4NE9rbXhvdEpNdlFRPSIsIml2UGFyYW1ldGVyU3BlYyI6IlZDaVZJSTM1QW95bFRTQnYiLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D&branch=v1.x)

 The **Amazon Kinesis Client Library for Java** (Amazon KCL) enables Java developers to easily consume and process data from [Amazon Kinesis][kinesis].

@ -30,18 +34,132 @@ To make it easier for developers to write record processors in other languages,

 ## Release Notes

-### Latest Release (1.9.1)
-* Added the ability to create a prepared checkpoint when at `SHARD_END`.
-  * [PR #301](https://github.com/awslabs/amazon-kinesis-client/pull/301)
-* Added the ability to subscribe to worker state change events.  
-  * [PR #291](https://github.com/awslabs/amazon-kinesis-client/pull/291)
-* Added support for custom lease managers.  
-  A custom `LeaseManager` can be provided to `Worker.Builder` that will be used to provide lease services. 
-  This makes it possible to implement custom lease management systems in addition to the default DynamoDB system.  
-  * [PR #297](https://github.com/awslabs/amazon-kinesis-client/pull/297)
-* Updated the version of the AWS Java SDK to 1.11.219
+### Latest Release (1.15.2 - Aug 14, 2024)
+* [#1371](https://github.com/awslabs/amazon-kinesis-client/pull/1371) Fix a bug in debug and trace logging levels for worker
+* [#1224](https://github.com/awslabs/amazon-kinesis-client/pull/1224) Modify RecordProcessorCheckpointer#advancePosition Metrics usage to ensure proper closure
+* [#1345](https://github.com/awslabs/amazon-kinesis-client/pull/1345) Generate wrappers from proto files instead of shipping them directly
+* [#1346](https://github.com/awslabs/amazon-kinesis-client/pull/1346) Upgrade com.google.protobuf:protobuf-java from 3.23.4 to 4.27.1
+* [#1338](https://github.com/awslabs/amazon-kinesis-client/pull/1338) Upgrade org.apache.logging.log4j:log4j-api from 2.20.0 to 2.23.1
+* [#1327](https://github.com/awslabs/amazon-kinesis-client/pull/1327) Upgrade com.google.guava:guava from 33.0.0-jre to 33.2.0-jre
+* [#1283](https://github.com/awslabs/amazon-kinesis-client/pull/1283) Upgrade com.fasterxml.jackson.core:jackson-core from 2.15.2 to 2.17.0
+* [#1284](https://github.com/awslabs/amazon-kinesis-client/pull/1284) Upgrade aws-java-sdk.version from 1.12.647 to 1.12.681
+* [#1288](https://github.com/awslabs/amazon-kinesis-client/pull/1288) Upgrade commons-logging:commons-logging from 1.2 to 1.3.1
+* [#1289](https://github.com/awslabs/amazon-kinesis-client/pull/1289) Upgrade org.projectlombok:lombok from 1.18.22 to 1.18.32
+* [#1248](https://github.com/awslabs/amazon-kinesis-client/pull/1248) Upgrade org.apache.maven.plugins:maven-surefire-plugin from 2.22.2 to 3.2.5
+* [#1234](https://github.com/awslabs/amazon-kinesis-client/pull/1234) Upgrade org.apache.maven.plugins:maven-javadoc-plugin from 3.4.1 to 3.6.3
+* [#1137](https://github.com/awslabs/amazon-kinesis-client/pull/1137) Upgrade maven-failsafe-plugin from 2.22.2 to 3.1.2
+* [#1134](https://github.com/awslabs/amazon-kinesis-client/pull/1134) Upgrade jackson-core from 2.15.0 to 2.15.2
+* [#1119](https://github.com/awslabs/amazon-kinesis-client/pull/1119) Upgrade maven-source-plugin from 3.2.1 to 3.3.0
+* [#1165](https://github.com/awslabs/amazon-kinesis-client/pull/1165) Upgrade protobuf-java from 3.19.6 to 3.23.4

-### For remaining release notes check **[CHANGELOG.md][changelog-md]**.
+### Release (1.15.1 - Feb 5, 2023)
+* [#1214](https://github.com/awslabs/amazon-kinesis-client/pull/1214) Added backoff logic for ShardSyncTaskIntegrationTest
+* [#1214](https://github.com/awslabs/amazon-kinesis-client/pull/1214) Upgrade Guava version from 31.0.1 to 32.1.1
+* [#1252](https://github.com/awslabs/amazon-kinesis-client/pull/1252) Upgrade aws-java-sdk from 1.12.406 to 1.12.647
+
+### Release (1.15.0 - Jun 8, 2023)
+* **[#1108](https://github.com/awslabs/amazon-kinesis-client/pull/1108) Add support for Stream ARNs**
+* [#1111](https://github.com/awslabs/amazon-kinesis-client/pull/1111) More consistent testing behavior with HashRangesAreAlwaysComplete
+* [#1054](https://github.com/awslabs/amazon-kinesis-client/pull/1054) Upgrade log4j-core from 2.17.1 to 2.20.0
+* [#1103](https://github.com/awslabs/amazon-kinesis-client/pull/1103) Upgrade jackson-core from 2.13.0 to 2.15.0
+* [#943](https://github.com/awslabs/amazon-kinesis-client/pull/943) Upgrade nexus-staging-maven-plugin from 1.6.8 to 1.6.13
+* [#1044](https://github.com/awslabs/amazon-kinesis-client/pull/1044) Upgrade aws-java-sdk.version from 1.12.406 to 1.12.408
+* [#1055](https://github.com/awslabs/amazon-kinesis-client/pull/1055) Upgrade maven-compiler-plugin from 3.10.0 to 3.11.0
+
+### Release (1.14.10 - Feb 15, 2023)
+* Updated aws-java-sdk from 1.12.130 to 1.12.406
+* Updated com.google.protobuf from 3.19.4 to 3.19.6
+	* [Issue #1026](https://github.com/awslabs/amazon-kinesis-client/issues/1026)
+	* [PR #1042](https://github.com/awslabs/amazon-kinesis-client/pull/1042)
+
+### Release (1.14.9 - Dec 14, 2022)
+* [#995](https://github.com/awslabs/amazon-kinesis-client/commit/372f98b21a91487e36612d528c56765a44b0aa86) Every other change for DynamoDBStreamsKinesis Adapter Compatibility
+* [#970](https://github.com/awslabs/amazon-kinesis-client/commit/251b331a2e0fd912b50f8b5a12d088bf0b3263b9) PeriodicShardSyncManager Changes Needed for DynamoDBStreamsKinesisAdapter
+
+### Release (1.14.8 - Feb 24, 2022)
+* [Bump log4j-core from 2.17.0 to 2.17.1](https://github.com/awslabs/amazon-kinesis-client/commit/94b138a9d9a502ee0f4f000bb0efd2766ebadc37)
+* [Bump protobuf-java from 3.19.1 to 3.19.4](https://github.com/awslabs/amazon-kinesis-client/commit/a809b12c43c57a3d6ad3827feb60e4322614259c)
+* [Bump maven-compiler-plugin from 3.8.1 to 3.10.0](https://github.com/awslabs/amazon-kinesis-client/commit/37b5d7b9a1ccad483469ef542a6a7237462b14f2)
+
+### Release (1.14.7 - Dec 22, 2021)
+* [#881](https://github.com/awslabs/amazon-kinesis-client/pull/881) Update log4j test dependency from 2.16.0 to 2.17.0 and some other dependencies
+
+### Release (1.14.6 - Dec 15, 2021)
+* [#876](https://github.com/awslabs/amazon-kinesis-client/pull/876) Update log4j test dependency from 2.15.0 to 2.16.0
+
+### Release (1.14.5 - Dec 10, 2021)
+* [#872](https://github.com/awslabs/amazon-kinesis-client/pull/872) Update log4j test dependency from 1.2.17 to 2.15.0
+* [#873](https://github.com/awslabs/amazon-kinesis-client/pull/873) Upgrading version of AWS Java SDK to 1.12.128
+
+### Release (1.14.4 - June 14, 2021)
+* [Milestone#61](https://github.com/awslabs/amazon-kinesis-client/milestone/61)
+* [#816](https://github.com/awslabs/amazon-kinesis-client/pull/816) Updated the Worker shutdown logic to make sure that the `LeaseCleanupManager` also terminates all the threads that it has started.
+* [#821](https://github.com/awslabs/amazon-kinesis-client/pull/821) Upgrading version of AWS Java SDK to 1.12.3
+
+### Release (1.14.3 - May 3, 2021)
+* [Milestone#60](https://github.com/awslabs/amazon-kinesis-client/milestone/60)
+* [#811](https://github.com/awslabs/amazon-kinesis-client/pull/811) Fixing a bug in `KinesisProxy` that can lead to undetermined behavior during partial failures.
+* [#811](https://github.com/awslabs/amazon-kinesis-client/pull/811) Adding guardrails to handle duplicate shards from the service.
+
+## Release (1.14.2 - February 24, 2021)
+* [Milestone#57](https://github.com/awslabs/amazon-kinesis-client/milestone/57)
+* [#790](https://github.com/awslabs/amazon-kinesis-client/pull/790) Fixing a bug that caused paginated `ListShards` calls with the `ShardFilter` parameter to fail when the lease table was being initialized.
+
+### Release (1.14.1 - January 27, 2021)
+* [Milestone#56](https://github.com/awslabs/amazon-kinesis-client/milestone/56)
+
+* Fix for cross DDB table interference when multiple KCL applications are run in same JVM.
+* Fix and guards to avoid potential checkpoint rewind during shard end, which may block children shard processing.
+* Fix for thread cycle wastage on InitializeTask for deleted shard.
+* Improved logging in LeaseCleanupManager that would indicate why certain shards are not cleaned up from the lease table.
+
+### Release (1.14.0 - August 17, 2020)
+
+* [Milestone#50](https://github.com/awslabs/amazon-kinesis-client/milestone/50)
+
+* Behavior of shard synchronization is moving from each worker independently learning about all existing shards to workers only discovering the children of shards that each worker owns. This optimizes memory usage, lease table IOPS usage, and number of calls made to kinesis for streams with high shard counts and/or frequent resharding.
+* When bootstrapping an empty lease table, KCL utilizes the ListShard API's filtering option (the ShardFilter optional request parameter) to retrieve and create leases only for a snapshot of shards open at the time specified by the ShardFilter parameter. The ShardFilter parameter enables you to filter out the response of the ListShards API, using the Type parameter. KCL uses the Type filter parameter and the following of its valid values to identify and return a snapshot of open shards that might require new leases.
+	* Currently, the following shard filters are supported:
+		* `AT_TRIM_HORIZON` - the response includes all the shards that were open at `TRIM_HORIZON`.
+		* `AT_LATEST` - the response includes only the currently open shards of the data stream.
+	    * `AT_TIMESTAMP` - the response includes all shards whose start timestamp is less than or equal to the given timestamp and end timestamp is greater than or equal to the given timestamp or still open.
+	* `ShardFilter` is used when creating leases for an empty lease table to initialize leases for a snapshot of shards specified at `KinesisClientLibConfiguration#initialPositionInStreamExtended`.
+	* For more information about ShardFilter, see the [official AWS documentation on ShardFilter](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ShardFilter.html).
+
+* Introducing support for the `ChildShards` response of the `GetRecords` API to perform lease/shard synchronization that happens at `SHARD_END` for closed shards, allowing a KCL worker to only create leases for the child shards of the shard it finished processing.
+	* For KCL 1.x applications, this uses the `ChildShards` response of the `GetRecords` API.
+	* For more information, see the official AWS Documentation on [GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html) and [ChildShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ChildShard.html).
+
+* KCL now also performs additional periodic shard/lease scans in order to identify any potential holes in the lease table to ensure the complete hash range of the stream is being processed and create leases for them if required. When `KinesisClientLibConfiguration#shardSyncStrategyType` is set to `ShardSyncStrategyType.SHARD_END`, `PeriodicShardSyncManager#leasesRecoveryAuditorInconsistencyConfidenceThreshold` will be used to determine the threshold for number of consecutive scans containing holes in the lease table after which to enforce a shard sync. When `KinesisClientLibConfiguration#shardSyncStrategyType` is set to `ShardSyncStrategyType.PERIODIC`, `leasesRecoveryAuditorInconsistencyConfidenceThreshold` is ignored.
+	* New configuration options are available to configure `PeriodicShardSyncManager` in `KinesisClientLibConfiguration`
+
+	| Name                                                  | Default | Description                                                                                                                                                                                                                                                                                       |
+	| ----------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+	| leasesRecoveryAuditorInconsistencyConfidenceThreshold | 3       | Confidence threshold for the periodic auditor job to determine if leases for a stream in the lease table is inconsistent. If the auditor finds same set of inconsistencies consecutively for a stream for this many times, then it would trigger a shard sync. Only used for `ShardSyncStrategyType.SHARD_END`. |
+
+	* New CloudWatch metrics are also now emitted to monitor the health of `PeriodicShardSyncManager`:
+
+	| Name                        | Description                                            |
+	| --------------------------- | ------------------------------------------------------ |
+	| NumStreamsWithPartialLeases | Number of streams that had holes in their hash ranges. |
+	| NumStreamsToSync            | Number of streams which underwent a full shard sync.   |
+
+* Introducing deferred lease cleanup. Leases will be deleted asynchronously by `LeaseCleanupManager` upon reaching `SHARD_END`, when a shard has either expired past the stream’s retention period or been closed as the result of a resharding operation.
+	* New configuration options are available to configure `LeaseCleanupManager`.
+
+	| Name                                | Default    | Description                                                                                               |
+	| ----------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------- |
+	| leaseCleanupIntervalMillis          | 1 minute   | Interval at which to run lease cleanup thread.                                                            |
+	| completedLeaseCleanupIntervalMillis | 5 minutes  | Interval at which to check if a lease is completed or not.                                                |
+	| garbageLeaseCleanupIntervalMillis   | 30 minutes | Interval at which to check if a lease is garbage (i.e trimmed past the stream's retention period) or not. |
+
+* Including an optimization to `KinesisShardSyncer` to only create leases for one layer of shards.
+* Changing default shard prioritization strategy to be `NoOpShardPrioritization` to allow prioritization of completed shards. Customers who are upgrading to this version and are reading from `TRIM_HORIZON` should continue using `ParentsFirstShardPrioritization` while upgrading.
+* Upgrading version of AWS SDK to 1.11.844.
+* [#719](https://github.com/awslabs/amazon-kinesis-client/pull/719) Upgrading version of Google Protobuf to 3.11.4.
+* [#712](https://github.com/awslabs/amazon-kinesis-client/pull/712) Allowing KCL to consider lease tables in `UPDATING` healthy.
+
+###### For remaining release notes check **[CHANGELOG.md][changelog-md]**.

 [kinesis]: http://aws.amazon.com/kinesis
 [kinesis-forum]: http://developer.amazonwebservices.com/connect/forum.jspa?forumID=169
--- a/pom.xml
+++ b/pom.xml
@ -6,7 +6,7 @@
  <artifactId>amazon-kinesis-client</artifactId>
  <packaging>jar</packaging>
  <name>Amazon Kinesis Client Library for Java</name>
-  <version>1.9.2-SNAPSHOT</version>
+  <version>1.15.3-SNAPSHOT</version>
  <description>The Amazon Kinesis Client Library for Java enables Java developers to easily consume and process data
    from Amazon Kinesis.
  </description>
@ -18,20 +18,26 @@

  <licenses>
    <license>
-      <name>Amazon Software License</name>
-      <url>https://aws.amazon.com/asl</url>
+      <name>Apache License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
      <distribution>repo</distribution>
    </license>
  </licenses>

  <properties>
-    <aws-java-sdk.version>1.11.344</aws-java-sdk.version>
+    <aws-java-sdk.version>1.12.681</aws-java-sdk.version>
+    <protobuf.version>4.27.1</protobuf.version>
    <sqlite4java.version>1.0.392</sqlite4java.version>
    <sqlite4java.native>libsqlite4java</sqlite4java.native>
    <sqlite4java.libpath>${project.build.directory}/test-lib</sqlite4java.libpath>
  </properties>

  <dependencies>
+    <dependency>
+      <groupId>com.amazonaws</groupId>
+      <artifactId>aws-java-sdk-core</artifactId>
+      <version>${aws-java-sdk.version}</version>
+    </dependency>
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-java-sdk-dynamodb</artifactId>
@ -50,27 +56,27 @@
    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
-      <version>18.0</version>
+      <version>33.2.0-jre</version>
    </dependency>
    <dependency>
      <groupId>com.google.protobuf</groupId>
      <artifactId>protobuf-java</artifactId>
-      <version>2.6.1</version>
+      <version>${protobuf.version}</version>
    </dependency>
    <dependency>
-      <groupId>commons-lang</groupId>
-      <artifactId>commons-lang</artifactId>
-      <version>2.6</version>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-lang3</artifactId>
+      <version>3.12.0</version>
    </dependency>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
-      <version>1.1.3</version>
+      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
-      <version>1.16.10</version>
+      <version>1.18.32</version>
      <scope>provided</scope>
    </dependency>

@ -78,7 +84,7 @@
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
-      <version>4.11</version>
+      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>

@ -99,16 +105,29 @@
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>DynamoDBLocal</artifactId>
-      <version>1.11.86</version>
+      <version>1.17.2</version>
      <scope>test</scope>
    </dependency>

    <dependency>
-      <groupId>log4j</groupId>
-      <artifactId>log4j</artifactId>
-      <version>1.2.17</version>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <version>2.24.3</version>
      <scope>test</scope>
    </dependency>
+           
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+      <version>2.23.1</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-core</artifactId>
+      <version>2.17.0</version>
+    </dependency>
  </dependencies>

  <repositories>
@ -131,12 +150,19 @@
  </developers>

  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.6.0</version>
+      </extension>
+    </extensions>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
-          <version>3.2</version>
+          <version>3.11.0</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
@ -147,10 +173,25 @@
    </pluginManagement>

    <plugins>
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
+        </configuration>
+      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
-        <version>2.19.1</version>
+        <version>3.2.5</version>
        <configuration>
          <excludes>
            <exclude>**/*IntegrationTest.java</exclude>
@ -166,7 +207,7 @@
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
-        <version>2.19.1</version>
+        <version>3.1.2</version>
        <configuration>
          <includes>
            <include>**/*IntegrationTest.java</include>
@ -252,7 +293,7 @@
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-javadoc-plugin</artifactId>
-        <version>2.10.3</version>
+        <version>3.6.3</version>
        <configuration>
          <excludePackageNames>com.amazonaws.services.kinesis.producer.protobuf</excludePackageNames>
        </configuration>
@ -268,7 +309,7 @@
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
-        <version>3.0.1</version>
+        <version>3.3.0</version>
        <executions>
          <execution>
            <id>attach-sources</id>
@ -281,6 +322,18 @@
    </plugins>

  </build>
+
+  <distributionManagement>
+    <snapshotRepository>
+      <id>sonatype-nexus-staging</id>
+      <url>https://aws.oss.sonatype.org/content/repositories/snapshots</url>
+    </snapshotRepository>
+    <repository>
+      <id>sonatype-nexus-staging</id>
+      <url>https://aws.oss.sonatype.org/service/local/staging/deploy/maven2/</url>
+    </repository>
+  </distributionManagement>
+
  <profiles>
    <profile>
      <id>disable-java8-doclint</id>
@ -288,9 +341,10 @@
        <jdk>[1.8,)</jdk>
      </activation>
      <properties>
-        <additionalparam>-Xdoclint:none</additionalparam>
+        <doclint>none</doclint>
      </properties>
    </profile>
+
    <profile>
      <id>publishing</id>
      <build>
@ -298,7 +352,7 @@
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-gpg-plugin</artifactId>
-            <version>1.5</version>
+            <version>3.0.1</version>
            <executions>
              <execution>
                <id>sign-artifacts</id>
@ -309,6 +363,17 @@
              </execution>
            </executions>
          </plugin>
+          <plugin>
+            <groupId>org.sonatype.plugins</groupId>
+            <artifactId>nexus-staging-maven-plugin</artifactId>
+            <version>1.6.13</version>
+            <extensions>true</extensions>
+            <configuration>
+              <serverId>sonatype-nexus-staging</serverId>
+              <nexusUrl>https://aws.oss.sonatype.org</nexusUrl>
+              <autoReleaseAfterClose>false</autoReleaseAfterClose>
+            </configuration>
+          </plugin>
        </plugins>
      </build>
    </profile>
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/AWSCredentialsProviderPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/AWSCredentialsProviderPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/BooleanPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/BooleanPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/ClientConfigurationPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/ClientConfigurationPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/DatePropertyValueDecorder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/DatePropertyValueDecorder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/IPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/IPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/InitialPositionInStreamPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/InitialPositionInStreamPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/IntegerPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/IntegerPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/KinesisClientLibConfigurator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/KinesisClientLibConfigurator.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/LongPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/LongPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/SetPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/SetPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/StringPropertyValueDecoder.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/config/StringPropertyValueDecoder.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.config;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/InvalidStateException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/InvalidStateException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibDependencyException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibDependencyException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibNonRetryableException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibNonRetryableException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibRetryableException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/KinesisClientLibRetryableException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/ShutdownException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/ShutdownException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/ThrottlingException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/ThrottlingException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/internal/BlockedOnParentShardException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/internal/BlockedOnParentShardException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions.internal;
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/internal/KinesisClientLibIOException.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/exceptions/internal/KinesisClientLibIOException.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.exceptions.internal;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/ICheckpoint.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/ICheckpoint.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.interfaces;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/IRecordProcessor.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/IRecordProcessor.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.interfaces;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/IRecordProcessorCheckpointer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/IRecordProcessorCheckpointer.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.interfaces;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/IRecordProcessorFactory.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/IRecordProcessorFactory.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.interfaces;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/v2/IRecordProcessor.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/v2/IRecordProcessor.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.interfaces.v2;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/v2/IRecordProcessorFactory.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/v2/IRecordProcessorFactory.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.interfaces.v2;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/v2/IShutdownNotificationAware.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/interfaces/v2/IShutdownNotificationAware.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.interfaces.v2;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/checkpoint/SentinelCheckpoint.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/checkpoint/SentinelCheckpoint.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.checkpoint;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/AsynchronousGetRecordsRetrievalStrategy.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/AsynchronousGetRecordsRetrievalStrategy.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -45,24 +45,24 @@ public class AsynchronousGetRecordsRetrievalStrategy implements GetRecordsRetrie
    private static final int TIME_TO_KEEP_ALIVE = 5;
    private static final int CORE_THREAD_POOL_COUNT = 1;

-    private final KinesisDataFetcher dataFetcher;
+    private final IDataFetcher dataFetcher;
    private final ExecutorService executorService;
    private final int retryGetRecordsInSeconds;
    private final String shardId;
    final Supplier<CompletionService<DataFetcherResult>> completionServiceSupplier;

-    public AsynchronousGetRecordsRetrievalStrategy(@NonNull final KinesisDataFetcher dataFetcher,
+    public AsynchronousGetRecordsRetrievalStrategy(@NonNull final IDataFetcher dataFetcher,
            final int retryGetRecordsInSeconds, final int maxGetRecordsThreadPool, String shardId) {
        this(dataFetcher, buildExector(maxGetRecordsThreadPool, shardId), retryGetRecordsInSeconds, shardId);
    }

-    public AsynchronousGetRecordsRetrievalStrategy(final KinesisDataFetcher dataFetcher,
+    public AsynchronousGetRecordsRetrievalStrategy(final IDataFetcher dataFetcher,
            final ExecutorService executorService, final int retryGetRecordsInSeconds, String shardId) {
        this(dataFetcher, executorService, retryGetRecordsInSeconds, () -> new ExecutorCompletionService<>(executorService),
                shardId);
    }

-    AsynchronousGetRecordsRetrievalStrategy(KinesisDataFetcher dataFetcher, ExecutorService executorService,
+    AsynchronousGetRecordsRetrievalStrategy(IDataFetcher dataFetcher, ExecutorService executorService,
            int retryGetRecordsInSeconds, Supplier<CompletionService<DataFetcherResult>> completionServiceSupplier,
            String shardId) {
        this.dataFetcher = dataFetcher;
@ -148,7 +148,7 @@ public class AsynchronousGetRecordsRetrievalStrategy implements GetRecordsRetrie
    }

    @Override
-    public KinesisDataFetcher getDataFetcher() {
+    public IDataFetcher getDataFetcher() {
        return dataFetcher;
    }
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/BlockOnParentShardTask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/BlockOnParentShardTask.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -30,7 +30,7 @@ import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
 * If we don't find a checkpoint for the parent shard(s), we assume they have been trimmed and directly
 * proceed with processing data from the shard.
 */
-class BlockOnParentShardTask implements ITask {
+public class BlockOnParentShardTask implements ITask {

    private static final Log LOG = LogFactory.getLog(BlockOnParentShardTask.class);
    private final ShardInfo shardInfo;
@ -45,7 +45,7 @@ class BlockOnParentShardTask implements ITask {
     * @param leaseManager Used to fetch the lease and checkpoint info for parent shards
     * @param parentShardPollIntervalMillis Sleep time if the parent shard has not completed processing
     */
-    BlockOnParentShardTask(ShardInfo shardInfo,
+    public BlockOnParentShardTask(ShardInfo shardInfo,
            ILeaseManager<KinesisClientLease> leaseManager,
            long parentShardPollIntervalMillis) {
        this.shardInfo = shardInfo;
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/BlockingGetRecordsCache.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/BlockingGetRecordsCache.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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. 
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/CheckpointValueComparator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/CheckpointValueComparator.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/DataFetcherResult.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/DataFetcherResult.java
@ -1,9 +1,16 @@
 /*
- * Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. Licensed under the Amazon Software License
- * (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at
- * http://aws.amazon.com/asl/ or in the "license" file accompanying this file. This file 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.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/DeterministicShuffleShardSyncLeaderDecider.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/DeterministicShuffleShardSyncLeaderDecider.java
@ -0,0 +1,153 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import java.time.Instant;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.BooleanSupplier;
+import java.util.stream.Collectors;
+
+import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
+import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
+import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
+import com.amazonaws.util.CollectionUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * An implementation of the {@code LeaderDecider} to elect leader(s) based on workerId.
+ * Leases are shuffled using a predetermined constant seed so that lease ordering is
+ * preserved across workers.
+ * This reduces the probability of choosing the leader workers co-located on the same
+ * host in case workerId starts with a common string (e.g. IP Address).
+ * Hence if a host has 3 workers, IPADDRESS_Worker1, IPADDRESS_Worker2, and IPADDRESS_Worker3,
+ * we don't end up choosing all 3 for shard sync as a result of natural ordering of Strings.
+ * This ensures redundancy for shard-sync during host failures.
+ */
+class DeterministicShuffleShardSyncLeaderDecider implements LeaderDecider {
+    // Fixed seed so that the shuffle order is preserved across workers
+    static final int DETERMINISTIC_SHUFFLE_SEED = 1947;
+    private static final Log LOG = LogFactory.getLog(DeterministicShuffleShardSyncLeaderDecider.class);
+
+    private static final long ELECTION_INITIAL_DELAY_MILLIS = 60 * 1000;
+    private static final long ELECTION_SCHEDULING_INTERVAL_MILLIS = 5 * 60 * 1000;
+    private static final int AWAIT_TERMINATION_MILLIS = 5000;
+
+    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+
+    private final ILeaseManager<KinesisClientLease> leaseManager;
+    private final int numPeriodicShardSyncWorkers;
+    private final ScheduledExecutorService leaderElectionThreadPool;
+
+    private volatile Set<String> leaders;
+
+    /**
+     *
+     * @param leaseManager LeaseManager instance used to fetch leases.
+     * @param leaderElectionThreadPool Thread-pool to be used for leaderElection.
+     * @param numPeriodicShardSyncWorkers Number of leaders that will be elected to perform periodic shard syncs.
+     */
+    DeterministicShuffleShardSyncLeaderDecider(ILeaseManager<KinesisClientLease> leaseManager, ScheduledExecutorService leaderElectionThreadPool,
+            int numPeriodicShardSyncWorkers) {
+        this.leaseManager = leaseManager;
+        this.leaderElectionThreadPool = leaderElectionThreadPool;
+        this.numPeriodicShardSyncWorkers = numPeriodicShardSyncWorkers;
+    }
+
+    /*
+     * Shuffles the leases deterministically and elects numPeriodicShardSyncWorkers number of workers
+     * as leaders (workers that will perform shard sync).
+     */
+    private void electLeaders() {
+        try {
+            LOG.debug("Started leader election at: " + Instant.now());
+            List<KinesisClientLease> leases = leaseManager.listLeases();
+            List<String> uniqueHosts = leases.stream().map(KinesisClientLease::getLeaseOwner)
+                    .filter(owner -> owner != null).distinct().sorted().collect(Collectors.toList());
+
+            Collections.shuffle(uniqueHosts, new Random(DETERMINISTIC_SHUFFLE_SEED));
+            int numShardSyncWorkers = Math.min(uniqueHosts.size(), numPeriodicShardSyncWorkers);
+            // In case value is currently being read, we wait for reading to complete before updating the variable.
+            // This is to prevent any ConcurrentModificationException exceptions.
+            readWriteLock.writeLock().lock();
+            leaders = new HashSet<>(uniqueHosts.subList(0, numShardSyncWorkers));
+            LOG.info("Elected leaders: " + String.join(", ", leaders));
+            LOG.debug("Completed leader election at: " + System.currentTimeMillis());
+        } catch (DependencyException | InvalidStateException | ProvisionedThroughputException e) {
+            LOG.error("Exception occurred while trying to fetch all leases for leader election", e);
+        } catch (Throwable t) {
+            LOG.error("Unknown exception during leader election.", t);
+        } finally {
+            readWriteLock.writeLock().unlock();
+        }
+    }
+
+    private boolean isWorkerLeaderForShardSync(String workerId) {
+        return CollectionUtils.isNullOrEmpty(leaders) ||
+            (!CollectionUtils.isNullOrEmpty(leaders) && leaders.contains(workerId));
+    }
+
+    @Override
+    public synchronized Boolean isLeader(String workerId) {
+        // if no leaders yet, synchronously get leaders. This will happen at first Shard Sync.
+        if (executeConditionCheckWithReadLock(() -> CollectionUtils.isNullOrEmpty(leaders))) {
+            electLeaders();
+            // start a scheduled executor that will periodically update leaders.
+            // The first run will be after a minute.
+            // We don't need jitter since it is scheduled with a fixed delay and time taken to scan leases
+            // will be different at different times and on different hosts/workers.
+            leaderElectionThreadPool.scheduleWithFixedDelay(this::electLeaders, ELECTION_INITIAL_DELAY_MILLIS,
+                ELECTION_SCHEDULING_INTERVAL_MILLIS, TimeUnit.MILLISECONDS);
+        }
+        return executeConditionCheckWithReadLock(() -> isWorkerLeaderForShardSync(workerId));
+    }
+
+    @Override
+    public synchronized void shutdown() {
+        try {
+            leaderElectionThreadPool.shutdown();
+            if (leaderElectionThreadPool.awaitTermination(AWAIT_TERMINATION_MILLIS, TimeUnit.MILLISECONDS)) {
+                LOG.info("Successfully stopped leader election on the worker");
+            } else {
+                leaderElectionThreadPool.shutdownNow();
+                LOG.info(String.format("Stopped leader election thread after awaiting termination for %d milliseconds",
+                        AWAIT_TERMINATION_MILLIS));
+            }
+
+        } catch (InterruptedException e) {
+            LOG.debug("Encountered InterruptedException while awaiting leader election threadPool termination");
+        }
+    }
+
+    // Execute condition checks using shared variables under a read-write lock.
+    private boolean executeConditionCheckWithReadLock(BooleanSupplier action) {
+        try {
+            readWriteLock.readLock().lock();
+            return action.getAsBoolean();
+        } finally {
+            readWriteLock.readLock().unlock();
+        }
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/DoesNothingPreparedCheckpointer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/DoesNothingPreparedCheckpointer.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/EmptyLeaseTableSynchronizer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/EmptyLeaseTableSynchronizer.java
@ -0,0 +1,98 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.impl.Lease;
+import com.amazonaws.services.kinesis.model.Shard;
+import lombok.AllArgsConstructor;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisShardSyncer.StartingSequenceNumberAndShardIdBasedComparator;
+
+/**
+ * Class to help create leases when the table is initially empty.
+ */
+@AllArgsConstructor
+class EmptyLeaseTableSynchronizer implements LeaseSynchronizer {
+
+    private static final Log LOG = LogFactory.getLog(EmptyLeaseTableSynchronizer.class);
+
+    /**
+     * Determines how to create leases when the lease table is initially empty. For this, we read all shards where
+     * the KCL is reading from. For any shards which are closed, we will discover their child shards through GetRecords
+     * child shard information.
+     *
+     * @param shards
+     * @param currentLeases
+     * @param initialPosition
+     * @param inconsistentShardIds
+     * @return
+     */
+    @Override
+    public List<KinesisClientLease> determineNewLeasesToCreate(List<Shard> shards,
+                                                               List<KinesisClientLease> currentLeases,
+                                                               InitialPositionInStreamExtended initialPosition,
+                                                               Set<String> inconsistentShardIds) {
+
+        final Map<String, Shard> shardIdToShardMapOfAllKinesisShards =
+                KinesisShardSyncer.constructShardIdToShardMap(shards);
+
+        currentLeases.forEach(lease -> LOG.debug("Existing lease: " + lease.getLeaseKey()));
+
+        final List<KinesisClientLease> newLeasesToCreate =
+                getLeasesToCreateForOpenAndClosedShards(initialPosition, shards);
+
+        final Comparator<KinesisClientLease> startingSequenceNumberComparator =
+                new StartingSequenceNumberAndShardIdBasedComparator(shardIdToShardMapOfAllKinesisShards);
+
+        newLeasesToCreate.sort(startingSequenceNumberComparator);
+        return newLeasesToCreate;
+    }
+
+    /**
+     * Helper method to create leases. For an empty lease table, we will be creating leases for all shards
+     * regardless of if they are open or closed. Closed shards will be unblocked via child shard information upon
+     * reaching SHARD_END.
+     */
+    private List<KinesisClientLease> getLeasesToCreateForOpenAndClosedShards(
+            InitialPositionInStreamExtended initialPosition,
+            List<Shard> shards) {
+
+        final Map<String, Lease> shardIdToNewLeaseMap = new HashMap<>();
+
+        for (Shard shard : shards) {
+            final String shardId = shard.getShardId();
+            final KinesisClientLease lease = KinesisShardSyncer.newKCLLease(shard);
+
+            final ExtendedSequenceNumber checkpoint = KinesisShardSyncer.convertToCheckpoint(initialPosition);
+            lease.setCheckpoint(checkpoint);
+
+            LOG.debug("Need to create a lease for shard with shardId " + shardId);
+            shardIdToNewLeaseMap.put(shardId, lease);
+        }
+
+        return new ArrayList(shardIdToNewLeaseMap.values());
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GetRecordsCache.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GetRecordsCache.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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. 
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GetRecordsRetrievalStrategy.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GetRecordsRetrievalStrategy.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -46,9 +46,9 @@ public interface GetRecordsRetrievalStrategy {
    boolean isShutdown();

    /**
-     * Returns the KinesisDataFetcher used to getRecords from Kinesis.
+     * Returns the IDataFetcher used to getRecords
     * 
-     * @return KinesisDataFetcher
+     * @return IDataFetcher
     */
-    KinesisDataFetcher getDataFetcher();
+    IDataFetcher getDataFetcher();
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GracefulShutdownContext.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GracefulShutdownContext.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GracefulShutdownCoordinator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/GracefulShutdownCoordinator.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IDataFetcher.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IDataFetcher.java
@ -0,0 +1,23 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;
+import com.amazonaws.services.kinesis.model.ChildShard;
+
+import java.util.List;
+
+public interface IDataFetcher {
+
+    DataFetcherResult getRecords(int maxRecords);
+
+    void initialize(String initialCheckpoint, InitialPositionInStreamExtended initialPositionInStream);
+
+    void initialize(ExtendedSequenceNumber initialCheckpoint, InitialPositionInStreamExtended initialPositionInStream);
+
+    void advanceIteratorTo(String sequenceNumber, InitialPositionInStreamExtended initialPositionInStream);
+
+    void restartIterator();
+
+    boolean isShardEndReached();
+
+    List<ChildShard> getChildShards();
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IPeriodicShardSyncManager.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IPeriodicShardSyncManager.java
@ -0,0 +1,28 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.google.common.annotations.VisibleForTesting;
+import lombok.Value;
+import lombok.experimental.Accessors;
+
+public interface IPeriodicShardSyncManager {
+
+    TaskResult start();
+
+    /**
+     * Runs ShardSync once, without scheduling further periodic ShardSyncs.
+     * @return TaskResult from shard sync
+     */
+    TaskResult syncShardsOnce();
+
+    void stop();
+
+    @Value
+    @Accessors(fluent = true)
+    @VisibleForTesting
+    class ShardSyncResponse {
+        private final boolean shouldDoShardSync;
+        private final boolean isHoleDetected;
+        private final String reasonForDecision;
+    }
+}
+
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IShardConsumer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IShardConsumer.java
@ -0,0 +1,25 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+public interface IShardConsumer {
+
+    boolean isSkipShardSyncAtWorkerInitializationIfLeasesExist();
+
+    enum TaskOutcome {
+        SUCCESSFUL, END_OF_SHARD, NOT_COMPLETE, FAILURE, LEASE_NOT_FOUND
+    }
+
+    boolean consumeShard();
+
+    boolean isShutdown();
+
+    ShutdownReason getShutdownReason();
+
+    boolean beginShutdown();
+
+    void notifyShutdownRequested(ShutdownNotification shutdownNotification);
+
+    KinesisConsumerStates.ShardConsumerState getCurrentState();
+
+    boolean isShutdownRequested();
+    
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IShardConsumerFactory.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/IShardConsumerFactory.java
@ -0,0 +1,34 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.interfaces.ICheckpoint;
+import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessor;
+import com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager;
+import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;
+
+import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+
+public interface IShardConsumerFactory {
+
+    /**
+     * Returns a shard consumer to be used for consuming a (assigned) shard.
+     *
+     * @return Returns a shard consumer object.
+     */
+    IShardConsumer createShardConsumer(ShardInfo shardInfo,
+                                       StreamConfig streamConfig,
+                                       ICheckpoint checkpointTracker,
+                                       IRecordProcessor recordProcessor,
+                                       RecordProcessorCheckpointer recordProcessorCheckpointer,
+                                       KinesisClientLibLeaseCoordinator leaseCoordinator,
+                                       long parentShardPollIntervalMillis,
+                                       boolean cleanupLeasesUponShardCompletion,
+                                       ExecutorService executorService,
+                                       IMetricsFactory metricsFactory,
+                                       long taskBackoffTimeMillis,
+                                       boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
+                                       Optional<Integer> retryGetRecordsInSeconds,
+                                       Optional<Integer> maxGetRecordsThreadPool,
+                                       KinesisClientLibConfiguration config, ShardSyncer shardSyncer, ShardSyncStrategy shardSyncStrategy,
+                                       LeaseCleanupManager leaseCleanupManager);
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ITask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ITask.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -20,7 +20,7 @@ import java.util.concurrent.Callable;
 * Interface for shard processing tasks.
 * A task may execute an application callback (e.g. initialize, process, shutdown).
 */
-interface ITask extends Callable<TaskResult> {
+public interface ITask extends Callable<TaskResult> {

    /**
     * Perform task logic.
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/InitialPositionInStream.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/InitialPositionInStream.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/InitialPositionInStreamExtended.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/InitialPositionInStreamExtended.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -20,7 +20,7 @@ import java.util.Date;
 * Class that houses the entities needed to specify the position in the stream from where a new application should
 * start.
 */
-class InitialPositionInStreamExtended {
+public class InitialPositionInStreamExtended {

    private final InitialPositionInStream position;
    private final Date timestamp;
@ -44,7 +44,7 @@ class InitialPositionInStreamExtended {
     *
     * @return The initial position in stream.
     */
-    protected InitialPositionInStream getInitialPositionInStream() {
+    public InitialPositionInStream getInitialPositionInStream() {
        return this.position;
    }

@ -54,11 +54,11 @@ class InitialPositionInStreamExtended {
     *
     * @return The timestamp from where we need to start the application.
     */
-    protected Date getTimestamp() {
+    public Date getTimestamp() {
        return this.timestamp;
    }

-    protected static InitialPositionInStreamExtended newInitialPosition(final InitialPositionInStream position) {
+    public static InitialPositionInStreamExtended newInitialPosition(final InitialPositionInStream position) {
        switch (position) {
            case LATEST:
                return new InitialPositionInStreamExtended(InitialPositionInStream.LATEST, null);
@ -69,7 +69,7 @@ class InitialPositionInStreamExtended {
        }
    }

-    protected static InitialPositionInStreamExtended newInitialPositionAtTimestamp(final Date timestamp) {
+    public static InitialPositionInStreamExtended newInitialPositionAtTimestamp(final Date timestamp) {
        if (timestamp == null) {
            throw new IllegalArgumentException("Timestamp must be specified for InitialPosition AT_TIMESTAMP");
        }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/InitializeTask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/InitializeTask.java
@ -1,19 +1,20 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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. 
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

+import com.amazonaws.services.kinesis.clientlibrary.exceptions.KinesisClientLibNonRetryableException;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

@ -28,7 +29,7 @@ import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
 /**
 * Task for initializing shard position and invoking the RecordProcessor initialize() API.
 */
-class InitializeTask implements ITask {
+public class InitializeTask implements ITask {

    private static final Log LOG = LogFactory.getLog(InitializeTask.class);

@ -36,7 +37,7 @@ class InitializeTask implements ITask {

    private final ShardInfo shardInfo;
    private final IRecordProcessor recordProcessor;
-    private final KinesisDataFetcher dataFetcher;
+    private final IDataFetcher dataFetcher;
    private final TaskType taskType = TaskType.INITIALIZE;
    private final ICheckpoint checkpoint;
    private final RecordProcessorCheckpointer recordProcessorCheckpointer;
@ -48,11 +49,11 @@ class InitializeTask implements ITask {
    /**
     * Constructor.
     */
-    InitializeTask(ShardInfo shardInfo,
+    public InitializeTask(ShardInfo shardInfo,
                   IRecordProcessor recordProcessor,
                   ICheckpoint checkpoint,
                   RecordProcessorCheckpointer recordProcessorCheckpointer,
-                   KinesisDataFetcher dataFetcher,
+                   IDataFetcher dataFetcher,
                   long backoffTimeMillis,
                   StreamConfig streamConfig,
                   GetRecordsCache getRecordsCache) {
@ -79,7 +80,15 @@ class InitializeTask implements ITask {

        try {
            LOG.debug("Initializing ShardId " + shardInfo.getShardId());
-            Checkpoint initialCheckpointObject = checkpoint.getCheckpointObject(shardInfo.getShardId());
+            Checkpoint initialCheckpointObject;
+            try {
+                initialCheckpointObject = checkpoint.getCheckpointObject(shardInfo.getShardId());
+            } catch (KinesisClientLibNonRetryableException e) {
+                LOG.error("Caught exception while fetching checkpoint for " + shardInfo.getShardId(), e);
+                final TaskResult result = new TaskResult(e);
+                result.leaseNotFound();
+                return result;
+            }
            ExtendedSequenceNumber initialCheckpoint = initialCheckpointObject.getCheckpoint();

            dataFetcher.initialize(initialCheckpoint.getSequenceNumber(), streamConfig.getInitialPositionInStream());
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisClientLibConfiguration.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisClientLibConfiguration.java
@ -1,28 +1,31 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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. 
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

+import java.time.Duration;
 import java.util.Date;
 import java.util.Optional;
+import java.util.regex.Pattern;
 import java.util.Set;

-import org.apache.commons.lang.Validate;
+import com.amazonaws.services.dynamodbv2.model.BillingMode;
+import org.apache.commons.lang3.Validate;

 import com.amazonaws.ClientConfiguration;
+import com.amazonaws.arn.Arn;
 import com.amazonaws.auth.AWSCredentialsProvider;
-import com.amazonaws.regions.RegionUtils;
 import com.amazonaws.services.kinesis.metrics.impl.MetricsHelper;
 import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsScope;
 import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
@ -42,7 +45,10 @@ public class KinesisClientLibConfiguration {
     * when the application starts for the first time and there is no checkpoint for the shard.
     */
    public static final InitialPositionInStream DEFAULT_INITIAL_POSITION_IN_STREAM = InitialPositionInStream.LATEST;
-
+    /**
+     * Default Billing mode for DDB when we need to create a new lease table. Default value is Provisioned which requires the customer to manage the IOPS on the lease table.
+     */
+    public static final BillingMode DEFAULT_DDB_BILLING_MODE = BillingMode.PROVISIONED;
    /**
     * Fail over time in milliseconds. A worker which does not renew it's lease within this time interval
     * will be regarded as having problems and it's shards will be assigned to other workers.
@ -57,7 +63,7 @@ public class KinesisClientLibConfiguration {
    public static final int DEFAULT_MAX_RECORDS = 10000;

    /**
-     * The default value for how long the {@link ShardConsumer} should sleep if no records are returned from the call to
+     * The default value for how long the {@link KinesisShardConsumer} should sleep if no records are returned from the call to
     * {@link com.amazonaws.services.kinesis.AmazonKinesis#getRecords(com.amazonaws.services.kinesis.model.GetRecordsRequest)}.
     */
    public static final long DEFAULT_IDLETIME_BETWEEN_READS_MILLIS = 1000L;
@ -86,6 +92,23 @@ public class KinesisClientLibConfiguration {
     */
    public static final boolean DEFAULT_CLEANUP_LEASES_UPON_SHARDS_COMPLETION = true;

+    /**
+     * Interval to run lease cleanup thread in {@link com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager}.
+     */
+    private static final long DEFAULT_LEASE_CLEANUP_INTERVAL_MILLIS = Duration.ofMinutes(1).toMillis();
+
+    /**
+     * Threshold in millis at which to check if there are any completed leases (leases for shards which have been
+     * closed as a result of a resharding operation) that need to be cleaned up.
+     */
+    private static final long DEFAULT_COMPLETED_LEASE_CLEANUP_THRESHOLD_MILLIS = Duration.ofMinutes(5).toMillis();
+
+    /**
+     * Threshold in millis at which to check if there are any garbage leases (leases for shards which no longer exist
+     * in the stream) that need to be cleaned up.
+     */
+    private static final long DEFAULT_GARBAGE_LEASE_CLEANUP_THRESHOLD_MILLIS = Duration.ofMinutes(30).toMillis();
+
    /**
     * Backoff time in milliseconds for Amazon Kinesis Client Library tasks (in the event of failures).
     */
@ -126,7 +149,7 @@ public class KinesisClientLibConfiguration {
    /**
     * User agent set when Amazon Kinesis Client Library makes AWS requests.
     */
-    public static final String KINESIS_CLIENT_LIB_USER_AGENT = "amazon-kinesis-client-library-java-1.9.1";
+    public static final String KINESIS_CLIENT_LIB_USER_AGENT = "amazon-kinesis-client-library-java-1.15.2";

    /**
     * KCL will validate client provided sequence numbers with a call to Amazon Kinesis before checkpointing for calls
@ -167,6 +190,21 @@ public class KinesisClientLibConfiguration {
     */
    public static final boolean DEFAULT_SKIP_SHARD_SYNC_AT_STARTUP_IF_LEASES_EXIST = false;

+    /**
+     * Default ShardSyncStrategy to be used for discovering new shards in the Stream.
+     */
+    public static final ShardSyncStrategyType DEFAULT_SHARD_SYNC_STRATEGY_TYPE = ShardSyncStrategyType.SHARD_END;
+
+    /**
+     * Default Lease Recovery Auditor execution period for SHARD_END ShardSyncStrategyType.
+     */
+    public static final long LEASES_RECOVERY_AUDITOR_EXECUTION_FREQUENCY_MILLIS = 2 * 60 * 1000L;
+
+    /**
+     * Default Lease Recovery Auditor inconsistency confidence threshold for running full shard sync for SHARD_END ShardSyncStrategyType.
+     */
+    public static final int LEASES_RECOVERY_AUDITOR_INCONSISTENCY_CONFIDENCE_THRESHOLD = 3;
+
    /**
     * Default Shard prioritization strategy.
     */
@ -192,9 +230,30 @@ public class KinesisClientLibConfiguration {
     */
    public static final int DEFAULT_MAX_LIST_SHARDS_RETRY_ATTEMPTS = 50;

+    /**
+     * The number of times the {@link Worker} will try to initialize before giving up.
+     */
+    public static final int DEFAULT_MAX_INITIALIZATION_ATTEMPTS = 20;
+
+    /**
+     * Pattern for a stream ARN. The valid format is
+     * {@code arn:aws:kinesis:<region>:<accountId>:stream/<streamName>}
+     * where {@code region} is the id representation of a {@link Region}.
+     */
+    private static final Pattern STREAM_ARN_PATTERN = Pattern.compile(
+            "arn:aws[^:]*:kinesis:(?<region>[-a-z0-9]+):(?<accountId>[0-9]{12}):stream/(?<streamName>.+)");
+
+    @Getter
+    private BillingMode billingMode;
    private String applicationName;
    private String tableName;
    private String streamName;
+
+    /**
+     * Kinesis stream ARN
+     */
+    @Getter
+    private Arn streamArn;
    private String kinesisEndpoint;
    private String dynamoDBEndpoint;
    private InitialPositionInStream initialPositionInStream;
@ -230,6 +289,12 @@ public class KinesisClientLibConfiguration {
    private boolean skipShardSyncAtWorkerInitializationIfLeasesExist;
    private ShardPrioritization shardPrioritization;
    private long shutdownGraceMillis;
+    private ShardSyncStrategyType shardSyncStrategyType;
+    private long leaseCleanupIntervalMillis;
+    private long completedLeaseCleanupThresholdMillis;
+    private long garbageLeaseCleanupThresholdMillis;
+    private long leasesRecoveryAuditorExecutionFrequencyMillis;
+    private int leasesRecoveryAuditorInconsistencyConfidenceThreshold;

    @Getter
    private Optional<Integer> timeoutInSeconds = Optional.empty();
@ -255,6 +320,9 @@ public class KinesisClientLibConfiguration {
    @Getter
    private int maxListShardsRetryAttempts = DEFAULT_MAX_LIST_SHARDS_RETRY_ATTEMPTS;

+    @Getter
+    private int maxInitializationAttempts = DEFAULT_MAX_INITIALIZATION_ATTEMPTS;
+
    /**
     * Constructor.
     *
@ -265,6 +333,7 @@ public class KinesisClientLibConfiguration {
     * @param credentialsProvider Provides credentials used to sign AWS requests
     * @param workerId Used to distinguish different workers/processes of a Kinesis application
     */
+    @Deprecated
    public KinesisClientLibConfiguration(String applicationName,
            String streamName,
            AWSCredentialsProvider credentialsProvider,
@ -284,6 +353,7 @@ public class KinesisClientLibConfiguration {
     * @param cloudWatchCredentialsProvider Provides credentials used to access CloudWatch
     * @param workerId Used to distinguish different workers/processes of a Kinesis application
     */
+    @Deprecated
    public KinesisClientLibConfiguration(String applicationName,
            String streamName,
            AWSCredentialsProvider kinesisCredentialsProvider,
@ -314,7 +384,7 @@ public class KinesisClientLibConfiguration {
                DEFAULT_METRICS_MAX_QUEUE_SIZE,
                DEFAULT_VALIDATE_SEQUENCE_NUMBER_BEFORE_CHECKPOINTING,
                null,
-                DEFAULT_SHUTDOWN_GRACE_MILLIS);
+                DEFAULT_SHUTDOWN_GRACE_MILLIS, DEFAULT_DDB_BILLING_MODE);
    }

    /**
@ -350,9 +420,11 @@ public class KinesisClientLibConfiguration {
     *        {@link RecordProcessorCheckpointer#checkpoint(String)}
     * @param regionName The region name for the service
     * @param shutdownGraceMillis The number of milliseconds before graceful shutdown terminates forcefully
+     * @param billingMode The DDB Billing mode to set for lease table creation.
     */
    // CHECKSTYLE:IGNORE HiddenFieldCheck FOR NEXT 26 LINES
    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 26 LINES
+    @Deprecated
    public KinesisClientLibConfiguration(String applicationName,
                                         String streamName,
                                         String kinesisEndpoint,
@ -376,7 +448,7 @@ public class KinesisClientLibConfiguration {
                                         int metricsMaxQueueSize,
                                         boolean validateSequenceNumberBeforeCheckpointing,
                                         String regionName,
-                                         long shutdownGraceMillis) {
+                                         long shutdownGraceMillis, BillingMode billingMode) {
        this(applicationName, streamName, kinesisEndpoint, null, initialPositionInStream, kinesisCredentialsProvider,
                dynamoDBCredentialsProvider, cloudWatchCredentialsProvider, failoverTimeMillis, workerId,
                maxRecords, idleTimeBetweenReadsInMillis,
@ -384,7 +456,7 @@ public class KinesisClientLibConfiguration {
                shardSyncIntervalMillis, cleanupTerminatedShardsBeforeExpiry,
                kinesisClientConfig, dynamoDBClientConfig, cloudWatchClientConfig,
                taskBackoffTimeMillis, metricsBufferTimeMillis, metricsMaxQueueSize,
-                validateSequenceNumberBeforeCheckpointing, regionName, shutdownGraceMillis);
+                validateSequenceNumberBeforeCheckpointing, regionName, shutdownGraceMillis, billingMode);
    }

    /**
@ -420,9 +492,11 @@ public class KinesisClientLibConfiguration {
     *        with a call to Amazon Kinesis before checkpointing for calls to
     *        {@link RecordProcessorCheckpointer#checkpoint(String)}
     * @param regionName The region name for the service
+     * @param billingMode The DDB Billing mode to set for lease table creation.
     */
    // CHECKSTYLE:IGNORE HiddenFieldCheck FOR NEXT 26 LINES
    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 26 LINES
+    @Deprecated
    public KinesisClientLibConfiguration(String applicationName,
                                         String streamName,
                                         String kinesisEndpoint,
@ -447,53 +521,16 @@ public class KinesisClientLibConfiguration {
                                         int metricsMaxQueueSize,
                                         boolean validateSequenceNumberBeforeCheckpointing,
                                         String regionName,
-                                         long shutdownGraceMillis) {
-        // Check following values are greater than zero
-        checkIsValuePositive("FailoverTimeMillis", failoverTimeMillis);
-        checkIsValuePositive("IdleTimeBetweenReadsInMillis", idleTimeBetweenReadsInMillis);
-        checkIsValuePositive("ParentShardPollIntervalMillis", parentShardPollIntervalMillis);
-        checkIsValuePositive("ShardSyncIntervalMillis", shardSyncIntervalMillis);
-        checkIsValuePositive("MaxRecords", (long) maxRecords);
-        checkIsValuePositive("TaskBackoffTimeMillis", taskBackoffTimeMillis);
-        checkIsValuePositive("MetricsBufferTimeMills", metricsBufferTimeMillis);
-        checkIsValuePositive("MetricsMaxQueueSize", (long) metricsMaxQueueSize);
-        checkIsValuePositive("ShutdownGraceMillis", shutdownGraceMillis);
-        this.applicationName = applicationName;
-        this.tableName = applicationName;
-        this.streamName = streamName;
-        this.kinesisEndpoint = kinesisEndpoint;
-        this.dynamoDBEndpoint = dynamoDBEndpoint;
-        this.initialPositionInStream = initialPositionInStream;
-        this.kinesisCredentialsProvider = kinesisCredentialsProvider;
-        this.dynamoDBCredentialsProvider = dynamoDBCredentialsProvider;
-        this.cloudWatchCredentialsProvider = cloudWatchCredentialsProvider;
-        this.failoverTimeMillis = failoverTimeMillis;
-        this.maxRecords = maxRecords;
-        this.idleTimeBetweenReadsInMillis = idleTimeBetweenReadsInMillis;
-        this.callProcessRecordsEvenForEmptyRecordList = callProcessRecordsEvenForEmptyRecordList;
-        this.parentShardPollIntervalMillis = parentShardPollIntervalMillis;
-        this.shardSyncIntervalMillis = shardSyncIntervalMillis;
-        this.cleanupLeasesUponShardCompletion = cleanupTerminatedShardsBeforeExpiry;
-        this.workerIdentifier = workerId;
-        this.kinesisClientConfig = checkAndAppendKinesisClientLibUserAgent(kinesisClientConfig);
-        this.dynamoDBClientConfig = checkAndAppendKinesisClientLibUserAgent(dynamoDBClientConfig);
-        this.cloudWatchClientConfig = checkAndAppendKinesisClientLibUserAgent(cloudWatchClientConfig);
-        this.taskBackoffTimeMillis = taskBackoffTimeMillis;
-        this.metricsBufferTimeMillis = metricsBufferTimeMillis;
-        this.metricsMaxQueueSize = metricsMaxQueueSize;
-        this.metricsLevel = DEFAULT_METRICS_LEVEL;
-        this.metricsEnabledDimensions = DEFAULT_METRICS_ENABLED_DIMENSIONS;
-        this.validateSequenceNumberBeforeCheckpointing = validateSequenceNumberBeforeCheckpointing;
-        this.regionName = regionName;
-        this.maxLeasesForWorker = DEFAULT_MAX_LEASES_FOR_WORKER;
-        this.maxLeasesToStealAtOneTime = DEFAULT_MAX_LEASES_TO_STEAL_AT_ONE_TIME;
-        this.initialLeaseTableReadCapacity = DEFAULT_INITIAL_LEASE_TABLE_READ_CAPACITY;
-        this.initialLeaseTableWriteCapacity = DEFAULT_INITIAL_LEASE_TABLE_WRITE_CAPACITY;
-        this.initialPositionInStreamExtended =
-                InitialPositionInStreamExtended.newInitialPosition(initialPositionInStream);
-        this.skipShardSyncAtWorkerInitializationIfLeasesExist = DEFAULT_SKIP_SHARD_SYNC_AT_STARTUP_IF_LEASES_EXIST;
-        this.shardPrioritization = DEFAULT_SHARD_PRIORITIZATION;
-        this.recordsFetcherFactory = new SimpleRecordsFetcherFactory();
+                                         long shutdownGraceMillis,
+                                         BillingMode billingMode) {
+
+        this(applicationName, streamName, kinesisEndpoint, dynamoDBEndpoint, initialPositionInStream, kinesisCredentialsProvider,
+                dynamoDBCredentialsProvider, cloudWatchCredentialsProvider, failoverTimeMillis, workerId, maxRecords, idleTimeBetweenReadsInMillis,
+                callProcessRecordsEvenForEmptyRecordList, parentShardPollIntervalMillis, shardSyncIntervalMillis, cleanupTerminatedShardsBeforeExpiry,
+                kinesisClientConfig, dynamoDBClientConfig, cloudWatchClientConfig, taskBackoffTimeMillis, metricsBufferTimeMillis,
+                metricsMaxQueueSize, validateSequenceNumberBeforeCheckpointing, regionName, shutdownGraceMillis, billingMode,
+                new SimpleRecordsFetcherFactory(), DEFAULT_LEASE_CLEANUP_INTERVAL_MILLIS, DEFAULT_COMPLETED_LEASE_CLEANUP_THRESHOLD_MILLIS,
+                DEFAULT_GARBAGE_LEASE_CLEANUP_THRESHOLD_MILLIS);
    }

    /**
@ -532,6 +569,7 @@ public class KinesisClientLibConfiguration {
     */
    // CHECKSTYLE:IGNORE HiddenFieldCheck FOR NEXT 26 LINES
    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 26 LINES
+    @Deprecated
    public KinesisClientLibConfiguration(String applicationName,
            String streamName,
            String kinesisEndpoint,
@ -557,6 +595,91 @@ public class KinesisClientLibConfiguration {
            boolean validateSequenceNumberBeforeCheckpointing,
            String regionName,
            RecordsFetcherFactory recordsFetcherFactory) {
+
+
+        this(applicationName, streamName, kinesisEndpoint, dynamoDBEndpoint, initialPositionInStream, kinesisCredentialsProvider,
+                dynamoDBCredentialsProvider, cloudWatchCredentialsProvider, failoverTimeMillis, workerId, maxRecords, idleTimeBetweenReadsInMillis,
+                callProcessRecordsEvenForEmptyRecordList, parentShardPollIntervalMillis, shardSyncIntervalMillis, cleanupTerminatedShardsBeforeExpiry,
+                kinesisClientConfig, dynamoDBClientConfig, cloudWatchClientConfig, taskBackoffTimeMillis, metricsBufferTimeMillis,
+                metricsMaxQueueSize, validateSequenceNumberBeforeCheckpointing, regionName, 0, DEFAULT_DDB_BILLING_MODE,
+                recordsFetcherFactory, DEFAULT_LEASE_CLEANUP_INTERVAL_MILLIS, DEFAULT_COMPLETED_LEASE_CLEANUP_THRESHOLD_MILLIS,
+                DEFAULT_GARBAGE_LEASE_CLEANUP_THRESHOLD_MILLIS);
+    }
+
+    /**
+     * @param applicationName Name of the Kinesis application
+     *        By default the application name is included in the user agent string used to make AWS requests. This
+     *        can assist with troubleshooting (e.g. distinguish requests made by separate applications).
+     * @param streamName Name of the Kinesis stream
+     * @param kinesisEndpoint Kinesis endpoint
+     * @param dynamoDBEndpoint DynamoDB endpoint
+     * @param initialPositionInStream One of LATEST or TRIM_HORIZON. The KinesisClientLibrary will start fetching
+     *        records from that location in the stream when an application starts up for the first time and there
+     *        are no checkpoints. If there are checkpoints, then we start from the checkpoint position.
+     * @param kinesisCredentialsProvider Provides credentials used to access Kinesis
+     * @param dynamoDBCredentialsProvider Provides credentials used to access DynamoDB
+     * @param cloudWatchCredentialsProvider Provides credentials used to access CloudWatch
+     * @param failoverTimeMillis Lease duration (leases not renewed within this period will be claimed by others)
+     * @param workerId Used to distinguish different workers/processes of a Kinesis application
+     * @param maxRecords Max records to read per Kinesis getRecords() call
+     * @param idleTimeBetweenReadsInMillis Idle time between calls to fetch data from Kinesis
+     * @param callProcessRecordsEvenForEmptyRecordList Call the IRecordProcessor::processRecords() API even if
+     *        GetRecords returned an empty record list.
+     * @param parentShardPollIntervalMillis Wait for this long between polls to check if parent shards are done
+     * @param shardSyncIntervalMillis Time between tasks to sync leases and Kinesis shards
+     * @param cleanupTerminatedShardsBeforeExpiry Clean up shards we've finished processing (don't wait for expiration
+     *        in Kinesis)
+     * @param kinesisClientConfig Client Configuration used by Kinesis client
+     * @param dynamoDBClientConfig Client Configuration used by DynamoDB client
+     * @param cloudWatchClientConfig Client Configuration used by CloudWatch client
+     * @param taskBackoffTimeMillis Backoff period when tasks encounter an exception
+     * @param metricsBufferTimeMillis Metrics are buffered for at most this long before publishing to CloudWatch
+     * @param metricsMaxQueueSize Max number of metrics to buffer before publishing to CloudWatch
+     * @param validateSequenceNumberBeforeCheckpointing whether KCL should validate client provided sequence numbers
+     *        with a call to Amazon Kinesis before checkpointing for calls to
+     *        {@link RecordProcessorCheckpointer#checkpoint(String)}
+     * @param regionName The region name for the service
+     * @param shutdownGraceMillis Time before gracefully shutdown forcefully terminates
+     * @param billingMode The DDB Billing mode to set for lease table creation.
+     * @param recordsFetcherFactory Factory to create the records fetcher to retrieve data from Kinesis for a given shard.
+     * @param leaseCleanupIntervalMillis Rate at which to run lease cleanup thread in
+     *        {@link com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager}
+     * @param completedLeaseCleanupThresholdMillis Threshold in millis at which to check if there are any completed leases
+     *        (leases for shards which have been closed as a result of a resharding operation) that need to be cleaned up.
+     * @param garbageLeaseCleanupThresholdMillis Threshold in millis at which to check if there are any garbage leases
+     *        (leases for shards which no longer exist in the stream) that need to be cleaned up.
+     */
+    public KinesisClientLibConfiguration(String applicationName,
+                                         String streamName,
+                                         String kinesisEndpoint,
+                                         String dynamoDBEndpoint,
+                                         InitialPositionInStream initialPositionInStream,
+                                         AWSCredentialsProvider kinesisCredentialsProvider,
+                                         AWSCredentialsProvider dynamoDBCredentialsProvider,
+                                         AWSCredentialsProvider cloudWatchCredentialsProvider,
+                                         long failoverTimeMillis,
+                                         String workerId,
+                                         int maxRecords,
+                                         long idleTimeBetweenReadsInMillis,
+                                         boolean callProcessRecordsEvenForEmptyRecordList,
+                                         long parentShardPollIntervalMillis,
+                                         long shardSyncIntervalMillis,
+                                         boolean cleanupTerminatedShardsBeforeExpiry,
+                                         ClientConfiguration kinesisClientConfig,
+                                         ClientConfiguration dynamoDBClientConfig,
+                                         ClientConfiguration cloudWatchClientConfig,
+                                         long taskBackoffTimeMillis,
+                                         long metricsBufferTimeMillis,
+                                         int metricsMaxQueueSize,
+                                         boolean validateSequenceNumberBeforeCheckpointing,
+                                         String regionName,
+                                         long shutdownGraceMillis,
+                                         BillingMode billingMode,
+                                         RecordsFetcherFactory recordsFetcherFactory,
+                                         long leaseCleanupIntervalMillis,
+                                         long completedLeaseCleanupThresholdMillis,
+                                         long garbageLeaseCleanupThresholdMillis) {
+
        // Check following values are greater than zero
        checkIsValuePositive("FailoverTimeMillis", failoverTimeMillis);
        checkIsValuePositive("IdleTimeBetweenReadsInMillis", idleTimeBetweenReadsInMillis);
@ -600,19 +723,117 @@ public class KinesisClientLibConfiguration {
        this.initialPositionInStreamExtended =
                InitialPositionInStreamExtended.newInitialPosition(initialPositionInStream);
        this.skipShardSyncAtWorkerInitializationIfLeasesExist = DEFAULT_SKIP_SHARD_SYNC_AT_STARTUP_IF_LEASES_EXIST;
+        this.shardSyncStrategyType = DEFAULT_SHARD_SYNC_STRATEGY_TYPE;
+        this.leasesRecoveryAuditorExecutionFrequencyMillis = LEASES_RECOVERY_AUDITOR_EXECUTION_FREQUENCY_MILLIS;
+        this.leasesRecoveryAuditorInconsistencyConfidenceThreshold = LEASES_RECOVERY_AUDITOR_INCONSISTENCY_CONFIDENCE_THRESHOLD;
        this.shardPrioritization = DEFAULT_SHARD_PRIORITIZATION;
        this.recordsFetcherFactory = recordsFetcherFactory;
+        this.leaseCleanupIntervalMillis = leaseCleanupIntervalMillis;
+        this.completedLeaseCleanupThresholdMillis = completedLeaseCleanupThresholdMillis;
+        this.garbageLeaseCleanupThresholdMillis = garbageLeaseCleanupThresholdMillis;
        this.shutdownGraceMillis = shutdownGraceMillis;
+        this.billingMode = billingMode;
+    }
+
+    /**
+     * Duplicate constructor to support stream ARN's in place of stream names.
+     *
+     * @param applicationName Name of the Kinesis application
+     *        By default the application name is included in the user agent string used to make AWS requests. This
+     *        can assist with troubleshooting (e.g. distinguish requests made by separate applications).
+     * @param streamArn Kinesis stream ARN
+     * @param kinesisEndpoint Kinesis endpoint
+     * @param dynamoDBEndpoint DynamoDB endpoint
+     * @param initialPositionInStream One of LATEST or TRIM_HORIZON. The KinesisClientLibrary will start fetching
+     *        records from that location in the stream when an application starts up for the first time and there
+     *        are no checkpoints. If there are checkpoints, then we start from the checkpoint position.
+     * @param kinesisCredentialsProvider Provides credentials used to access Kinesis
+     * @param dynamoDBCredentialsProvider Provides credentials used to access DynamoDB
+     * @param cloudWatchCredentialsProvider Provides credentials used to access CloudWatch
+     * @param failoverTimeMillis Lease duration (leases not renewed within this period will be claimed by others)
+     * @param workerId Used to distinguish different workers/processes of a Kinesis application
+     * @param maxRecords Max records to read per Kinesis getRecords() call
+     * @param idleTimeBetweenReadsInMillis Idle time between calls to fetch data from Kinesis
+     * @param callProcessRecordsEvenForEmptyRecordList Call the IRecordProcessor::processRecords() API even if
+     *        GetRecords returned an empty record list.
+     * @param parentShardPollIntervalMillis Wait for this long between polls to check if parent shards are done
+     * @param shardSyncIntervalMillis Time between tasks to sync leases and Kinesis shards
+     * @param cleanupTerminatedShardsBeforeExpiry Clean up shards we've finished processing (don't wait for expiration
+     *        in Kinesis)
+     * @param kinesisClientConfig Client Configuration used by Kinesis client
+     * @param dynamoDBClientConfig Client Configuration used by DynamoDB client
+     * @param cloudWatchClientConfig Client Configuration used by CloudWatch client
+     * @param taskBackoffTimeMillis Backoff period when tasks encounter an exception
+     * @param metricsBufferTimeMillis Metrics are buffered for at most this long before publishing to CloudWatch
+     * @param metricsMaxQueueSize Max number of metrics to buffer before publishing to CloudWatch
+     * @param validateSequenceNumberBeforeCheckpointing whether KCL should validate client provided sequence numbers
+     *        with a call to Amazon Kinesis before checkpointing for calls to
+     *        {@link RecordProcessorCheckpointer#checkpoint(String)}
+     * @param regionName The region name for the service
+     * @param shutdownGraceMillis Time before gracefully shutdown forcefully terminates
+     * @param billingMode The DDB Billing mode to set for lease table creation.
+     * @param recordsFetcherFactory Factory to create the records fetcher to retrieve data from Kinesis for a given shard.
+     * @param leaseCleanupIntervalMillis Rate at which to run lease cleanup thread in
+     *        {@link com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager}
+     * @param completedLeaseCleanupThresholdMillis Threshold in millis at which to check if there are any completed leases
+     *        (leases for shards which have been closed as a result of a resharding operation) that need to be cleaned up.
+     * @param garbageLeaseCleanupThresholdMillis Threshold in millis at which to check if there are any garbage leases
+     *        (leases for shards which no longer exist in the stream) that need to be cleaned up.
+     */
+    public KinesisClientLibConfiguration(String applicationName,
+            Arn streamArn,
+            String kinesisEndpoint,
+            String dynamoDBEndpoint,
+            InitialPositionInStream initialPositionInStream,
+            AWSCredentialsProvider kinesisCredentialsProvider,
+            AWSCredentialsProvider dynamoDBCredentialsProvider,
+            AWSCredentialsProvider cloudWatchCredentialsProvider,
+            long failoverTimeMillis,
+            String workerId,
+            int maxRecords,
+            long idleTimeBetweenReadsInMillis,
+            boolean callProcessRecordsEvenForEmptyRecordList,
+            long parentShardPollIntervalMillis,
+            long shardSyncIntervalMillis,
+            boolean cleanupTerminatedShardsBeforeExpiry,
+            ClientConfiguration kinesisClientConfig,
+            ClientConfiguration dynamoDBClientConfig,
+            ClientConfiguration cloudWatchClientConfig,
+            long taskBackoffTimeMillis,
+            long metricsBufferTimeMillis,
+            int metricsMaxQueueSize,
+            boolean validateSequenceNumberBeforeCheckpointing,
+            String regionName,
+            long shutdownGraceMillis,
+            BillingMode billingMode,
+            RecordsFetcherFactory recordsFetcherFactory,
+            long leaseCleanupIntervalMillis,
+            long completedLeaseCleanupThresholdMillis,
+            long garbageLeaseCleanupThresholdMillis) {
+        this(applicationName, streamArn.getResource().getResource(), kinesisEndpoint, dynamoDBEndpoint, initialPositionInStream, kinesisCredentialsProvider,
+                dynamoDBCredentialsProvider, cloudWatchCredentialsProvider, failoverTimeMillis, workerId, maxRecords, idleTimeBetweenReadsInMillis,
+                callProcessRecordsEvenForEmptyRecordList, parentShardPollIntervalMillis, shardSyncIntervalMillis, cleanupTerminatedShardsBeforeExpiry,
+                kinesisClientConfig, dynamoDBClientConfig, cloudWatchClientConfig, taskBackoffTimeMillis, metricsBufferTimeMillis,
+                metricsMaxQueueSize, validateSequenceNumberBeforeCheckpointing, regionName, shutdownGraceMillis, billingMode,
+                recordsFetcherFactory, leaseCleanupIntervalMillis, completedLeaseCleanupThresholdMillis, garbageLeaseCleanupThresholdMillis);
+        checkIsValidStreamArn(streamArn);
+        this.streamArn = streamArn;
    }

    // Check if value is positive, otherwise throw an exception
-    private void checkIsValuePositive(String key, long value) {
+    private static void checkIsValuePositive(String key, long value) {
        if (value <= 0) {
            throw new IllegalArgumentException("Value of " + key
                    + " should be positive, but current value is " + value);
        }
    }

+    private static void checkIsValidStreamArn(Arn streamArn) {
+        if (!STREAM_ARN_PATTERN.matcher(streamArn.toString()).matches()) {
+            throw new IllegalArgumentException("Invalid streamArn " + streamArn);
+        }
+    }
+
    // Check if user agent in configuration is the default agent.
    // If so, replace it with application name plus KINESIS_CLIENT_LIB_USER_AGENT.
    // If not, append KINESIS_CLIENT_LIB_USER_AGENT to the end.
@ -811,6 +1032,29 @@ public class KinesisClientLibConfiguration {
        return cleanupLeasesUponShardCompletion;
    }

+    /**
+     * @return Interval in millis at which to run lease cleanup thread in {@link com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager}
+     */
+    public long leaseCleanupIntervalMillis() {
+        return leaseCleanupIntervalMillis;
+    }
+
+    /**
+     * @return Interval in millis at which to check if there are any completed leases (leases for shards which have been
+     * closed as a result of a resharding operation) that need to be cleaned up.
+     */
+    public long completedLeaseCleanupThresholdMillis() {
+        return completedLeaseCleanupThresholdMillis;
+    }
+
+    /**
+     * @return Interval in millis at which to check if there are any garbage leases (leases for shards which no longer
+     * exist in the stream) that need to be cleaned up.
+     */
+    public long garbageLeaseCleanupThresholdMillis() {
+        return garbageLeaseCleanupThresholdMillis;
+    }
+
    /**
     * @return true if we should ignore child shards which have open parents
     */
@ -840,6 +1084,27 @@ public class KinesisClientLibConfiguration {
        return skipShardSyncAtWorkerInitializationIfLeasesExist;
    }

+    /**
+     * @return ShardSyncStrategyType to be used by KCL to process the Stream.
+     */
+    public ShardSyncStrategyType getShardSyncStrategyType() {
+        return shardSyncStrategyType;
+    }
+
+    /**
+     * @return leasesRecoveryAuditorExecutionFrequencyMillis to be used by SHARD_END ShardSyncStrategyType.
+     */
+    public long getLeasesRecoveryAuditorExecutionFrequencyMillis() {
+        return leasesRecoveryAuditorExecutionFrequencyMillis;
+    }
+
+    /**
+     * @return leasesRecoveryAuditorInconsistencyConfidenceThreshold to be used by SHARD_END ShardSyncStrategyType.
+     */
+    public int getLeasesRecoveryAuditorInconsistencyConfidenceThreshold() {
+        return leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+    }
+
    /**
     * @return Max leases this Worker can handle at a time
     */
@ -872,7 +1137,7 @@ public class KinesisClientLibConfiguration {
     * Keeping it protected to forbid outside callers from depending on this internal object.
     * @return The initialPositionInStreamExtended object.
     */
-    protected InitialPositionInStreamExtended getInitialPositionInStreamExtended() {
+    public InitialPositionInStreamExtended getInitialPositionInStreamExtended() {
        return initialPositionInStreamExtended;
    }

@ -898,6 +1163,25 @@ public class KinesisClientLibConfiguration {
        return shutdownGraceMillis;
    }

+    /**
+     * @param streamName Kinesis stream name
+     * @return KinesisClientLibConfiguration
+     */
+    public KinesisClientLibConfiguration withStreamName(String streamName) {
+        this.streamName = streamName;
+        return this;
+    }
+
+    /**
+     * @param streamArn Kinesis stream ARN
+     * @return KinesisClientLibConfiguration
+     */
+    public KinesisClientLibConfiguration withStreamArn(Arn streamArn) {
+        checkIsValidStreamArn(streamArn);
+        this.streamArn = streamArn;
+        return this;
+    }
+
    /*
    // CHECKSTYLE:IGNORE HiddenFieldCheck FOR NEXT 190 LINES
    /**
@ -1140,6 +1424,15 @@ public class KinesisClientLibConfiguration {
        return this;
    }

+    /**
+     * The DDB Billing mode to set for lease table creation.
+     * @param billingMode - Either PAY_PER_REQUEST, or PROVISIONED; Defaults to PROVISIONED
+     * @return
+     */
+    public KinesisClientLibConfiguration withBillingMode(BillingMode billingMode){
+        this.billingMode = billingMode == null ? DEFAULT_DDB_BILLING_MODE : billingMode;
+        return this;
+    }
    /**
     * Sets metrics level that should be enabled. Possible values are:
     * NONE
@ -1199,6 +1492,33 @@ public class KinesisClientLibConfiguration {
        return this;
    }

+    /**
+     * @param shardSyncStrategyType ShardSyncStrategy type for KCL.
+     * @return {@link KinesisClientLibConfiguration}
+     */
+    public KinesisClientLibConfiguration withShardSyncStrategyType(ShardSyncStrategyType shardSyncStrategyType) {
+        this.shardSyncStrategyType = shardSyncStrategyType;
+        return this;
+    }
+
+    /**
+     * @param leasesRecoveryAuditorExecutionFrequencyMillis Leases Recovery Auditor Execution period.
+     * @return {@link KinesisClientLibConfiguration}
+     */
+    public KinesisClientLibConfiguration withLeasesRecoveryAuditorExecutionFrequencyMillis(long leasesRecoveryAuditorExecutionFrequencyMillis) {
+        this.leasesRecoveryAuditorExecutionFrequencyMillis = leasesRecoveryAuditorExecutionFrequencyMillis;
+        return this;
+    }
+
+    /**
+     * @param leasesRecoveryAuditorInconsistencyConfidenceThreshold Leases Recovery Auditor Execution inconsistency confidence threshold.
+     * @return {@link KinesisClientLibConfiguration}
+     */
+    public KinesisClientLibConfiguration withLeasesRecoveryAuditorInconsistencyConfidenceThreshold(int leasesRecoveryAuditorInconsistencyConfidenceThreshold) {
+        this.leasesRecoveryAuditorInconsistencyConfidenceThreshold = leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+        return this;
+    }
+
    /**
     *
     * @param regionName The region name for the service
@ -1416,4 +1736,49 @@ public class KinesisClientLibConfiguration {
        this.maxListShardsRetryAttempts = maxListShardsRetryAttempts;
        return this;
    }
+
+    /**
+     * @param maxInitializationAttempts Max number of Worker initialization attempts before giving up
+     * @return
+     */
+    public KinesisClientLibConfiguration withMaxInitializationAttempts(int maxInitializationAttempts) {
+        checkIsValuePositive("maxInitializationAttempts", maxInitializationAttempts);
+        this.maxInitializationAttempts = maxInitializationAttempts;
+        return this;
+    }
+
+    /**
+     * @param leaseCleanupIntervalMillis Rate at which to run lease cleanup thread in
+     * {@link com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager}
+     * @return
+     */
+    public KinesisClientLibConfiguration withLeaseCleanupIntervalMillis(long leaseCleanupIntervalMillis) {
+        checkIsValuePositive("leaseCleanupIntervalMillis", leaseCleanupIntervalMillis);
+        this.leaseCleanupIntervalMillis = leaseCleanupIntervalMillis;
+        return this;
+    }
+
+    /**
+     * Threshold in millis at which to check if there are any completed leases (leases for shards which have been
+     * closed as a result of a resharding operation) that need to be cleaned up.
+     * @param completedLeaseCleanupThresholdMillis
+     * @return
+     */
+    public KinesisClientLibConfiguration withCompletedLeaseCleanupThresholdMillis(long completedLeaseCleanupThresholdMillis) {
+        checkIsValuePositive("completedLeaseCleanupThresholdMillis", completedLeaseCleanupThresholdMillis);
+        this.completedLeaseCleanupThresholdMillis = completedLeaseCleanupThresholdMillis;
+        return this;
+    }
+
+    /**
+     * Threshold in millis at which to check if there are any garbage leases (leases for shards which no longer exist
+     * in the stream) that need to be cleaned up.
+     * @param garbageLeaseCleanupThresholdMillis
+     * @return
+     */
+    public KinesisClientLibConfiguration withGarbageLeaseCleanupThresholdMillis(long  garbageLeaseCleanupThresholdMillis) {
+        checkIsValuePositive("garbageLeaseCleanupThresholdMillis",  garbageLeaseCleanupThresholdMillis);
+        this.garbageLeaseCleanupThresholdMillis =  garbageLeaseCleanupThresholdMillis;
+        return this;
+    }
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisClientLibLeaseCoordinator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisClientLibLeaseCoordinator.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -21,7 +21,16 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ExecutorService;

+import com.amazonaws.services.kinesis.leases.impl.GenericLeaseSelector;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.impl.LeaseCoordinator;
+import com.amazonaws.services.kinesis.leases.impl.LeaseRenewer;
+import com.amazonaws.services.kinesis.leases.impl.LeaseTaker;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseRenewer;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseTaker;
+import com.amazonaws.services.kinesis.leases.interfaces.LeaseSelector;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

@ -36,20 +45,19 @@ import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber
 import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
 import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
 import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
-import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
-import com.amazonaws.services.kinesis.leases.impl.LeaseCoordinator;
 import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
 import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;

 /**
 * This class is used to coordinate/manage leases owned by this worker process and to get/set checkpoints.
 */
-class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLease> implements ICheckpoint {
+public class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLease> implements ICheckpoint {

    private static final Log LOG = LogFactory.getLog(KinesisClientLibLeaseCoordinator.class);

    private static final long DEFAULT_INITIAL_LEASE_TABLE_READ_CAPACITY = 10L;
    private static final long DEFAULT_INITIAL_LEASE_TABLE_WRITE_CAPACITY = 10L;
+    private static final LeaseSelector<KinesisClientLease> DEFAULT_LEASE_SELECTOR = new GenericLeaseSelector<KinesisClientLease>();

    private final ILeaseManager<KinesisClientLease> leaseManager;

@ -61,12 +69,11 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
     * @param workerIdentifier Used to identify this worker process
     * @param leaseDurationMillis Duration of a lease in milliseconds
     * @param epsilonMillis Delta for timing operations (e.g. checking lease expiry)
+     * @param leaseSelector Lease selector which decides which leases to take
     */
-    public KinesisClientLibLeaseCoordinator(ILeaseManager<KinesisClientLease> leaseManager,
-            String workerIdentifier,
-            long leaseDurationMillis,
-            long epsilonMillis) {
-        super(leaseManager, workerIdentifier, leaseDurationMillis, epsilonMillis);
+    public KinesisClientLibLeaseCoordinator(ILeaseManager<KinesisClientLease> leaseManager, String workerIdentifier,
+            long leaseDurationMillis, long epsilonMillis, LeaseSelector<KinesisClientLease> leaseSelector) {
+        super(leaseManager, leaseSelector, workerIdentifier, leaseDurationMillis, epsilonMillis);
        this.leaseManager = leaseManager;
    }

@ -75,19 +82,30 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
     * @param workerIdentifier Used to identify this worker process
     * @param leaseDurationMillis Duration of a lease in milliseconds
     * @param epsilonMillis Delta for timing operations (e.g. checking lease expiry)
+     */
+    public KinesisClientLibLeaseCoordinator(ILeaseManager<KinesisClientLease> leaseManager, String workerIdentifier,
+            long leaseDurationMillis, long epsilonMillis) {
+        this(leaseManager, workerIdentifier, leaseDurationMillis, epsilonMillis, DEFAULT_LEASE_SELECTOR);
+    }
+
+    /**
+     * @param leaseManager Lease manager which provides CRUD lease operations.
+     * @param leaseSelector Lease selector which decides which leases to take
+     * @param workerIdentifier Used to identify this worker process
+     * @param leaseDurationMillis Duration of a lease in milliseconds
+     * @param epsilonMillis Delta for timing operations (e.g. checking lease expiry)
     * @param metricsFactory Metrics factory used to emit metrics
     */
    public KinesisClientLibLeaseCoordinator(ILeaseManager<KinesisClientLease> leaseManager,
-            String workerIdentifier,
-            long leaseDurationMillis,
-            long epsilonMillis,
-            IMetricsFactory metricsFactory) {
-        super(leaseManager, workerIdentifier, leaseDurationMillis, epsilonMillis, metricsFactory);
+            LeaseSelector<KinesisClientLease> leaseSelector, String workerIdentifier, long leaseDurationMillis,
+            long epsilonMillis, IMetricsFactory metricsFactory) {
+        super(leaseManager, leaseSelector, workerIdentifier, leaseDurationMillis, epsilonMillis, metricsFactory);
        this.leaseManager = leaseManager;
    }

    /**
     * @param leaseManager Lease manager which provides CRUD lease operations.
+     * @param leaseSelector Lease selector which decides which leases to take
     * @param workerIdentifier Used to identify this worker process
     * @param leaseDurationMillis Duration of a lease in milliseconds
     * @param epsilonMillis Delta for timing operations (e.g. checking lease expiry)
@ -96,18 +114,22 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
     * @param metricsFactory Metrics factory used to emit metrics
     */
    public KinesisClientLibLeaseCoordinator(ILeaseManager<KinesisClientLease> leaseManager,
-            String workerIdentifier,
-            long leaseDurationMillis,
-            long epsilonMillis,
-            int maxLeasesForWorker,
-            int maxLeasesToStealAtOneTime,
-            int maxLeaseRenewerThreadCount,
+            LeaseSelector<KinesisClientLease> leaseSelector, String workerIdentifier, long leaseDurationMillis,
+            long epsilonMillis, int maxLeasesForWorker, int maxLeasesToStealAtOneTime, int maxLeaseRenewerThreadCount,
            IMetricsFactory metricsFactory) {
-        super(leaseManager, workerIdentifier, leaseDurationMillis, epsilonMillis, maxLeasesForWorker,
+        super(leaseManager, leaseSelector, workerIdentifier, leaseDurationMillis, epsilonMillis, maxLeasesForWorker,
                maxLeasesToStealAtOneTime, maxLeaseRenewerThreadCount, metricsFactory);
        this.leaseManager = leaseManager;
    }

+    public KinesisClientLibLeaseCoordinator(ILeaseManager<KinesisClientLease> leaseManager,
+            ILeaseTaker<KinesisClientLease> leaseTaker, ILeaseRenewer<KinesisClientLease> leaseRenewer,
+            final long leaseDurationMillis, final long epsilonMillis, final int maxLeasesForWorker,
+            final int maxLeasesToStealAtOneTime, final IMetricsFactory metricsFactory) {
+        super(leaseTaker, leaseRenewer, leaseDurationMillis, epsilonMillis, maxLeasesForWorker, maxLeasesToStealAtOneTime, metricsFactory);
+        this.leaseManager = leaseManager;
+    }
+
    /**
     * @param readCapacity The DynamoDB table used for tracking leases will be provisioned with the specified initial
     *        read capacity
@ -136,25 +158,24 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea

    /**
     * Sets the checkpoint for a shard and updates ownerSwitchesSinceCheckpoint.
-     * 
+     *
     * @param shardId shardId to update the checkpoint for
     * @param checkpoint checkpoint value to set
     * @param concurrencyToken obtained by calling Lease.getConcurrencyToken for a currently held lease
-     * 
+     *
     * @return true if checkpoint update succeeded, false otherwise
-     * 
+     *
     * @throws InvalidStateException if lease table does not exist
     * @throws ProvisionedThroughputException if DynamoDB update fails due to lack of capacity
     * @throws DependencyException if DynamoDB update fails in an unexpected way
     */
    boolean setCheckpoint(String shardId, ExtendedSequenceNumber checkpoint, UUID concurrencyToken)
-        throws DependencyException, InvalidStateException, ProvisionedThroughputException {
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException {
        KinesisClientLease lease = getCurrentlyHeldLease(shardId);
        if (lease == null) {
            LOG.info(String.format(
                    "Worker %s could not update checkpoint for shard %s because it does not hold the lease",
-                    getWorkerIdentifier(),
-                    shardId));
+                    getWorkerIdentifier(), shardId));
            return false;
        }

@ -170,7 +191,7 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
     */
    @Override
    public void setCheckpoint(String shardId, ExtendedSequenceNumber checkpointValue, String concurrencyToken)
-        throws KinesisClientLibException {
+            throws KinesisClientLibException {
        try {
            boolean wasSuccessful = setCheckpoint(shardId, checkpointValue, UUID.fromString(concurrencyToken));
            if (!wasSuccessful) {
@ -220,8 +241,7 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
        if (lease == null) {
            LOG.info(String.format(
                    "Worker %s could not prepare checkpoint for shard %s because it does not hold the lease",
-                    getWorkerIdentifier(),
-                    shardId));
+                    getWorkerIdentifier(), shardId));
            return false;
        }

@ -234,12 +254,11 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
     * {@inheritDoc}
     */
    @Override
-    public void prepareCheckpoint(String shardId,
-                                  ExtendedSequenceNumber pendingCheckpointValue,
-                                  String concurrencyToken) throws KinesisClientLibException {
+    public void prepareCheckpoint(String shardId, ExtendedSequenceNumber pendingCheckpointValue,
+            String concurrencyToken) throws KinesisClientLibException {
        try {
-            boolean wasSuccessful =
-                    prepareCheckpoint(shardId, pendingCheckpointValue, UUID.fromString(concurrencyToken));
+            boolean wasSuccessful = prepareCheckpoint(shardId, pendingCheckpointValue,
+                    UUID.fromString(concurrencyToken));
            if (!wasSuccessful) {
                throw new ShutdownException(
                        "Can't prepare checkpoint - instance doesn't hold the lease for this shard");
@ -260,13 +279,17 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
     */
    @Override
    public Checkpoint getCheckpointObject(String shardId) throws KinesisClientLibException {
+        String errorMessage = "Unable to fetch checkpoint for shardId " + shardId;
        try {
            KinesisClientLease lease = leaseManager.getLease(shardId);
+            if (lease == null) {
+                // This is a KinesisClientLibNonRetryableException
+                throw new com.amazonaws.services.kinesis.clientlibrary.exceptions.InvalidStateException(errorMessage);
+            }
            return new Checkpoint(lease.getCheckpoint(), lease.getPendingCheckpoint());
        } catch (DependencyException | InvalidStateException | ProvisionedThroughputException e) {
-            String message = "Unable to fetch checkpoint for shardId " + shardId;
-            LOG.error(message, e);
-            throw new KinesisClientLibIOException(message, e);
+            LOG.error(errorMessage, e);
+            throw new KinesisClientLibIOException(errorMessage, e);
        }
    }

@ -303,12 +326,12 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
     * @throws ProvisionedThroughputException
     */
    void initialize() throws ProvisionedThroughputException, DependencyException, IllegalStateException {
-        final boolean newTableCreated =
-                leaseManager.createLeaseTableIfNotExists(initialLeaseTableReadCapacity, initialLeaseTableWriteCapacity);
+        final boolean newTableCreated = leaseManager
+                .createLeaseTableIfNotExists(initialLeaseTableReadCapacity, initialLeaseTableWriteCapacity);
        if (newTableCreated) {
            LOG.info(String.format(
-                "Created new lease table for coordinator with initial read capacity of %d and write capacity of %d.",
-                initialLeaseTableReadCapacity, initialLeaseTableWriteCapacity));
+                    "Created new lease table for coordinator with initial read capacity of %d and write capacity of %d.",
+                    initialLeaseTableReadCapacity, initialLeaseTableWriteCapacity));
        }
        // Need to wait for table in active state.
        final long secondsBetweenPolls = 10L;
@ -321,7 +344,7 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea

    /**
     * Package access for testing.
-     * 
+     *
     * @throws DependencyException
     * @throws InvalidStateException
     */
@ -331,7 +354,7 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea

    /**
     * Package access for testing.
-     * 
+     *
     * @throws DependencyException
     * @throws InvalidStateException
     */
@ -342,10 +365,10 @@ class KinesisClientLibLeaseCoordinator extends LeaseCoordinator<KinesisClientLea
    /**
     * Used to get information about leases for Kinesis shards (e.g. sync shards and leases, check on parent shard
     * completion).
-     * 
+     *
     * @return LeaseManager
     */
-    ILeaseManager<KinesisClientLease> getLeaseManager() {
+    public ILeaseManager<KinesisClientLease> getLeaseManager() {
        return leaseManager;
    }

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisConsumerStates.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisConsumerStates.java
@ -1,25 +1,25 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

 /**
- * Top level container for all the possible states a {@link ShardConsumer} can be in. The logic for creation of tasks,
+ * Top level container for all the possible states a {@link KinesisShardConsumer} can be in. The logic for creation of tasks,
 * and state transitions is contained within the {@link ConsumerState} objects.
 *
 * <h2>State Diagram</h2>
- * 
+ *
 * <pre>
 *       +-------------------+
 *       | Waiting on Parent |                               +------------------+
@ -64,12 +64,12 @@ package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
 *                                                          +-------------------+
 * </pre>
 */
-class ConsumerStates {
+public class KinesisConsumerStates {

    /**
     * Enumerates processing states when working on a shard.
     */
-    enum ShardConsumerState {
+    public enum ShardConsumerState {
        // @formatter:off
        WAITING_ON_PARENT_SHARDS(new BlockedOnParentState()),
        INITIALIZING(new InitializingState()),
@ -94,24 +94,24 @@ class ConsumerStates {
    /**
     * Represents a the current state of the consumer. This handles the creation of tasks for the consumer, and what to
     * do when a transition occurs.
-     * 
+     *
     */
-    interface ConsumerState {
+    public interface ConsumerState {
        /**
         * Creates a new task for this state using the passed in consumer to build the task. If there is no task
         * required for this state it may return a null value. {@link ConsumerState}'s are allowed to modify the
         * consumer during the execution of this method.
-         * 
+         *
         * @param consumer
         *            the consumer to use build the task, or execute state.
         * @return a valid task for this state or null if there is no task required.
         */
-        ITask createTask(ShardConsumer consumer);
+        ITask createTask(KinesisShardConsumer consumer);

        /**
         * Provides the next state of the consumer upon success of the task return by
-         * {@link ConsumerState#createTask(ShardConsumer)}.
-         * 
+         * {@link ConsumerState#createTask(KinesisShardConsumer)}.
+         *
         * @return the next state that the consumer should transition to, this may be the same object as the current
         *         state.
         */
@ -120,7 +120,7 @@ class ConsumerStates {
        /**
         * Provides the next state of the consumer when a shutdown has been requested. The returned state is dependent
         * on the current state, and the shutdown reason.
-         * 
+         *
         * @param shutdownReason
         *            the reason that a shutdown was requested
         * @return the next state that the consumer should transition to, this may be the same object as the current
@ -129,9 +129,9 @@ class ConsumerStates {
        ConsumerState shutdownTransition(ShutdownReason shutdownReason);

        /**
-         * The type of task that {@link ConsumerState#createTask(ShardConsumer)} would return. This is always a valid state
+         * The type of task that {@link ConsumerState#createTask(KinesisShardConsumer)} would return. This is always a valid state
         * even if createTask would return a null value.
-         * 
+         *
         * @return the type of task that this state represents.
         */
        TaskType getTaskType();
@ -139,7 +139,7 @@ class ConsumerStates {
        /**
         * An enumeration represent the type of this state. Different consumer states may return the same
         * {@link ShardConsumerState}.
-         * 
+         *
         * @return the type of consumer state this represents.
         */
        ShardConsumerState getState();
@ -149,7 +149,7 @@ class ConsumerStates {
    }

    /**
-     * The initial state that any {@link ShardConsumer} should start in.
+     * The initial state that any {@link KinesisShardConsumer} should start in.
     */
    static final ConsumerState INITIAL_STATE = ShardConsumerState.WAITING_ON_PARENT_SHARDS.getConsumerState();

@ -187,7 +187,7 @@ class ConsumerStates {
    static class BlockedOnParentState implements ConsumerState {

        @Override
-        public ITask createTask(ShardConsumer consumer) {
+        public ITask createTask(KinesisShardConsumer consumer) {
            return new BlockOnParentShardTask(consumer.getShardInfo(), consumer.getLeaseManager(),
                    consumer.getParentShardPollIntervalMillis());
        }
@ -199,7 +199,7 @@ class ConsumerStates {

        @Override
        public ConsumerState shutdownTransition(ShutdownReason shutdownReason) {
-            return ShardConsumerState.SHUTDOWN_COMPLETE.getConsumerState();
+            return ShardConsumerState.SHUTTING_DOWN.getConsumerState();
        }

        @Override
@ -247,10 +247,10 @@ class ConsumerStates {
     * </dd>
     * </dl>
     */
-    static class InitializingState implements ConsumerState {
+    public static class InitializingState implements ConsumerState {

        @Override
-        public ITask createTask(ShardConsumer consumer) {
+        public ITask createTask(KinesisShardConsumer consumer) {
            return new InitializeTask(consumer.getShardInfo(),
                    consumer.getRecordProcessor(),
                    consumer.getCheckpoint(),
@ -311,7 +311,7 @@ class ConsumerStates {
    static class ProcessingState implements ConsumerState {

        @Override
-        public ITask createTask(ShardConsumer consumer) {
+        public ITask createTask(KinesisShardConsumer consumer) {
            return new ProcessTask(consumer.getShardInfo(),
                    consumer.getStreamConfig(),
                    consumer.getRecordProcessor(),
@ -358,10 +358,10 @@ class ConsumerStates {
     * <h2>Valid Transitions</h2>
     * <dl>
     * <dt>Success</dt>
-     * <dd>Success shouldn't normally be called since the {@link ShardConsumer} is marked for shutdown.</dd>
+     * <dd>Success shouldn't normally be called since the {@link KinesisShardConsumer} is marked for shutdown.</dd>
     * <dt>Shutdown</dt>
     * <dd>At this point records are being retrieved, and processed. An explicit shutdown will allow the record
-     * processor one last chance to checkpoint, and then the {@link ShardConsumer} will be held in an idle state.
+     * processor one last chance to checkpoint, and then the {@link KinesisShardConsumer} will be held in an idle state.
     * <dl>
     * <dt>{@link ShutdownReason#REQUESTED}</dt>
     * <dd>Remains in the {@link ShardConsumerState#SHUTDOWN_REQUESTED}, but the state implementation changes to
@ -377,7 +377,7 @@ class ConsumerStates {
    static class ShutdownNotificationState implements ConsumerState {

        @Override
-        public ITask createTask(ShardConsumer consumer) {
+        public ITask createTask(KinesisShardConsumer consumer) {
            return new ShutdownNotificationTask(consumer.getRecordProcessor(),
                    consumer.getRecordProcessorCheckpointer(),
                    consumer.getShutdownNotification(),
@ -414,24 +414,24 @@ class ConsumerStates {
    }

    /**
-     * Once the {@link ShutdownNotificationState} has been completed the {@link ShardConsumer} must not re-enter any of the
-     * processing states. This state idles the {@link ShardConsumer} until the worker triggers the final shutdown state.
+     * Once the {@link ShutdownNotificationState} has been completed the {@link KinesisShardConsumer} must not re-enter any of the
+     * processing states. This state idles the {@link KinesisShardConsumer} until the worker triggers the final shutdown state.
     *
     * <h2>Valid Transitions</h2>
     * <dl>
     * <dt>Success</dt>
     * <dd>
     * <p>
-     * Success shouldn't normally be called since the {@link ShardConsumer} is marked for shutdown.
+     * Success shouldn't normally be called since the {@link KinesisShardConsumer} is marked for shutdown.
     * </p>
     * <p>
     * Remains in the {@link ShutdownNotificationCompletionState}
     * </p>
     * </dd>
     * <dt>Shutdown</dt>
-     * <dd>At this point the {@link ShardConsumer} has notified the record processor of the impending shutdown, and is
+     * <dd>At this point the {@link KinesisShardConsumer} has notified the record processor of the impending shutdown, and is
     * waiting that notification. While waiting for the notification no further processing should occur on the
-     * {@link ShardConsumer}.
+     * {@link KinesisShardConsumer}.
     * <dl>
     * <dt>{@link ShutdownReason#REQUESTED}</dt>
     * <dd>Remains in the {@link ShardConsumerState#SHUTDOWN_REQUESTED}, and the state implementation remains
@ -447,7 +447,7 @@ class ConsumerStates {
    static class ShutdownNotificationCompletionState implements ConsumerState {

        @Override
-        public ITask createTask(ShardConsumer consumer) {
+        public ITask createTask(KinesisShardConsumer consumer) {
            return null;
        }

@ -481,14 +481,14 @@ class ConsumerStates {
    }

    /**
-     * This state is entered if the {@link ShardConsumer} loses its lease, or reaches the end of the shard.
+     * This state is entered if the {@link KinesisShardConsumer} loses its lease, or reaches the end of the shard.
     *
     * <h2>Valid Transitions</h2>
     * <dl>
     * <dt>Success</dt>
     * <dd>
     * <p>
-     * Success shouldn't normally be called since the {@link ShardConsumer} is marked for shutdown.
+     * Success shouldn't normally be called since the {@link KinesisShardConsumer} is marked for shutdown.
     * </p>
     * <p>
     * Transitions to the {@link ShutdownCompleteState}
@ -497,7 +497,7 @@ class ConsumerStates {
     * <dt>Shutdown</dt>
     * <dd>At this point the record processor has processed the final shutdown indication, and depending on the shutdown
     * reason taken the correct course of action. From this point on there should be no more interactions with the
-     * record processor or {@link ShardConsumer}.
+     * record processor or {@link KinesisShardConsumer}.
     * <dl>
     * <dt>{@link ShutdownReason#REQUESTED}</dt>
     * <dd>
@ -519,8 +519,8 @@ class ConsumerStates {
    static class ShuttingDownState implements ConsumerState {

        @Override
-        public ITask createTask(ShardConsumer consumer) {
-            return new ShutdownTask(consumer.getShardInfo(),
+        public ITask createTask(KinesisShardConsumer consumer) {
+            return new KinesisShutdownTask(consumer.getShardInfo(),
                    consumer.getRecordProcessor(),
                    consumer.getRecordProcessorCheckpointer(),
                    consumer.getShutdownReason(),
@ -528,9 +528,11 @@ class ConsumerStates {
                    consumer.getStreamConfig().getInitialPositionInStream(),
                    consumer.isCleanupLeasesOfCompletedShards(),
                    consumer.isIgnoreUnexpectedChildShards(),
-                    consumer.getLeaseManager(),
+                    consumer.getLeaseCoordinator(),
                    consumer.getTaskBackoffTimeMillis(),
-                    consumer.getGetRecordsCache());
+                    consumer.getGetRecordsCache(), consumer.getShardSyncer(),
+                    consumer.getShardSyncStrategy(), consumer.getChildShards(),
+                    consumer.getLeaseCleanupManager());
        }

        @Override
@ -560,21 +562,21 @@ class ConsumerStates {
    }

    /**
-     * This is the final state for the {@link ShardConsumer}. This occurs once all shutdown activities are completed.
+     * This is the final state for the {@link KinesisShardConsumer}. This occurs once all shutdown activities are completed.
     *
     * <h2>Valid Transitions</h2>
     * <dl>
     * <dt>Success</dt>
     * <dd>
     * <p>
-     * Success shouldn't normally be called since the {@link ShardConsumer} is marked for shutdown.
+     * Success shouldn't normally be called since the {@link KinesisShardConsumer} is marked for shutdown.
     * </p>
     * <p>
     * Remains in the {@link ShutdownCompleteState}
     * </p>
     * </dd>
     * <dt>Shutdown</dt>
-     * <dd>At this point the all shutdown activites are completed, and the {@link ShardConsumer} should not take any
+     * <dd>At this point the all shutdown activites are completed, and the {@link KinesisShardConsumer} should not take any
     * further actions.
     * <dl>
     * <dt>{@link ShutdownReason#REQUESTED}</dt>
@ -597,7 +599,7 @@ class ConsumerStates {
    static class ShutdownCompleteState implements ConsumerState {

        @Override
-        public ITask createTask(ShardConsumer consumer) {
+        public ITask createTask(KinesisShardConsumer consumer) {
            if (consumer.getShutdownNotification() != null) {
                consumer.getShutdownNotification().shutdownComplete();
            }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisDataFetcher.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisDataFetcher.java
@ -1,23 +1,26 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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. 
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

 import java.util.Collections;
 import java.util.Date;
+import java.util.List;

-import org.apache.commons.lang.StringUtils;
+import com.amazonaws.SdkClientException;
+import com.amazonaws.services.kinesis.model.ChildShard;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

@ -36,7 +39,7 @@ import lombok.Data;
 /**
 * Used to get data from Amazon Kinesis. Tracks iterator state internally.
 */
-class KinesisDataFetcher {
+public class KinesisDataFetcher implements IDataFetcher{

    private static final Log LOG = LogFactory.getLog(KinesisDataFetcher.class);

@ -47,6 +50,7 @@ class KinesisDataFetcher {
    private boolean isInitialized;
    private String lastKnownSequenceNumber;
    private InitialPositionInStreamExtended initialPositionInStream;
+    private List<ChildShard> childShards = Collections.emptyList();

    /**
     *
@ -77,6 +81,7 @@ class KinesisDataFetcher {
                return TERMINAL_RESULT;
            }
        } else {
+            LOG.info("Skipping fetching records from Kinesis for shard " + shardId + ": nextIterator is null.");
            return TERMINAL_RESULT;
        }
    }
@ -84,8 +89,11 @@ class KinesisDataFetcher {
    final DataFetcherResult TERMINAL_RESULT = new DataFetcherResult() {
        @Override
        public GetRecordsResult getResult() {
-            return new GetRecordsResult().withMillisBehindLatest(null).withRecords(Collections.emptyList())
-                    .withNextShardIterator(null);
+            return new GetRecordsResult()
+                    .withMillisBehindLatest(null)
+                    .withRecords(Collections.emptyList())
+                    .withNextShardIterator(null)
+                    .withChildShards(Collections.emptyList());
        }

        @Override
@ -112,11 +120,20 @@ class KinesisDataFetcher {

        @Override
        public GetRecordsResult accept() {
+            if (!isValidResult(result)) {
+                // Throwing SDK exception when the GetRecords result is not valid. This will allow PrefetchGetRecordsCache to retry the GetRecords call.
+                throw new SdkClientException("Shard " + shardId +": GetRecordsResult is not valid. NextShardIterator: " + result.getNextShardIterator()
+                                                     + ". ChildShards: " + result.getChildShards());
+            }
            nextIterator = result.getNextShardIterator();
            if (!CollectionUtils.isNullOrEmpty(result.getRecords())) {
                lastKnownSequenceNumber = Iterables.getLast(result.getRecords()).getSequenceNumber();
            }
            if (nextIterator == null) {
+                LOG.info("Reached shard end: nextIterator is null in AdvancingResult.accept for shard " + shardId + ". childShards: " + result.getChildShards());
+                if (!CollectionUtils.isNullOrEmpty(result.getChildShards())) {
+                    childShards = result.getChildShards();
+                }
                isShardEndReached = true;
            }
            return getResult();
@ -128,6 +145,23 @@ class KinesisDataFetcher {
        }
    }

+    private boolean isValidResult(GetRecordsResult getRecordsResult) {
+        // GetRecords result should contain childShard information. There are two valid combination for the nextShardIterator and childShards
+        // If the GetRecords call does not reach the shard end, getRecords result should contain a non-null nextShardIterator and an empty list of childShards.
+        // If the GetRecords call reaches the shard end, getRecords result should contain a null nextShardIterator and a non-empty list of childShards.
+        // All other combinations are invalid and indicating an issue with GetRecords result from Kinesis service.
+        if (getRecordsResult.getNextShardIterator() == null && CollectionUtils.isNullOrEmpty(getRecordsResult.getChildShards()) ||
+                getRecordsResult.getNextShardIterator() != null && !CollectionUtils.isNullOrEmpty(getRecordsResult.getChildShards())) {
+            return false;
+        }
+        for (ChildShard childShard : getRecordsResult.getChildShards()) {
+            if (CollectionUtils.isNullOrEmpty(childShard.getParentShards())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
    /**
     * Initializes this KinesisDataFetcher's iterator based on the checkpointed sequence number.
     * @param initialCheckpoint Current checkpoint sequence number for this shard.
@ -139,8 +173,7 @@ class KinesisDataFetcher {
        isInitialized = true;
    }

-    public void initialize(ExtendedSequenceNumber initialCheckpoint,
-            InitialPositionInStreamExtended initialPositionInStream) {
+    public void initialize(ExtendedSequenceNumber initialCheckpoint, InitialPositionInStreamExtended initialPositionInStream) {
        LOG.info("Initializing shard " + shardId + " with " + initialCheckpoint.getSequenceNumber());
        advanceIteratorTo(initialCheckpoint.getSequenceNumber(), initialPositionInStream);
        isInitialized = true;
@ -152,7 +185,7 @@ class KinesisDataFetcher {
     * @param sequenceNumber advance the iterator to the record at this sequence number.
     * @param initialPositionInStream The initialPositionInStream.
     */
-    void advanceIteratorTo(String sequenceNumber, InitialPositionInStreamExtended initialPositionInStream) {
+    public void advanceIteratorTo(String sequenceNumber, InitialPositionInStreamExtended initialPositionInStream) {
        if (sequenceNumber == null) {
            throw new IllegalArgumentException("SequenceNumber should not be null: shardId " + shardId);
        } else if (sequenceNumber.equals(SentinelCheckpoint.LATEST.toString())) {
@ -167,7 +200,9 @@ class KinesisDataFetcher {
            nextIterator = getIterator(ShardIteratorType.AT_SEQUENCE_NUMBER.toString(), sequenceNumber);
        }
        if (nextIterator == null) {
+            LOG.info("Reached shard end: cannot advance iterator for shard " + shardId);
            isShardEndReached = true;
+            // TODO: transition to ShuttingDown state on shardend instead to shutdown state for enqueueing this for cleanup
        }
        this.lastKnownSequenceNumber = sequenceNumber;
        this.initialPositionInStream = initialPositionInStream;
@ -241,15 +276,18 @@ class KinesisDataFetcher {
    /**
     * @return the shardEndReached
     */
-    protected boolean isShardEndReached() {
+    public boolean isShardEndReached() {
        return isShardEndReached;
    }

+    public List<ChildShard> getChildShards() {
+        return childShards;
+    }
+
    /** Note: This method has package level access for testing purposes.
     * @return nextIterator
     */
    String getNextIterator() {
        return nextIterator;
    }
-
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisLeaseCleanupValidator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisLeaseCleanupValidator.java
@ -0,0 +1,51 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.exceptions.internal.KinesisClientLibIOException;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.util.Set;
+
+/**
+ * Represents the class that decides if a lease is eligible for cleanup.
+ */
+@Deprecated
+class KinesisLeaseCleanupValidator implements LeaseCleanupValidator {
+
+    private static final Log LOG = LogFactory.getLog(KinesisLeaseCleanupValidator.class);
+
+    /**
+     * @param lease Candidate shard we are considering for deletion.
+     * @param currentKinesisShardIds
+     * @return true if neither the shard (corresponding to the lease), nor its parents are present in
+     *         currentKinesisShardIds
+     * @throws KinesisClientLibIOException Thrown if currentKinesisShardIds contains a parent shard but not the child
+     *         shard (we are evaluating for deletion).
+     */
+    @Override
+    public boolean isCandidateForCleanup(KinesisClientLease lease, Set<String> currentKinesisShardIds) throws KinesisClientLibIOException {
+        boolean isCandidateForCleanup = true;
+
+        if (currentKinesisShardIds.contains(lease.getLeaseKey())) {
+            isCandidateForCleanup = false;
+        } else {
+            LOG.info("Found lease for non-existent shard: " + lease.getLeaseKey() + ". Checking its parent shards");
+            Set<String> parentShardIds = lease.getParentShardIds();
+            for (String parentShardId : parentShardIds) {
+
+                // Throw an exception if the parent shard exists (but the child does not).
+                // This may be a (rare) race condition between fetching the shard list and Kinesis expiring shards.
+                if (currentKinesisShardIds.contains(parentShardId)) {
+                    String message =
+                            "Parent shard " + parentShardId + " exists but not the child shard "
+                                    + lease.getLeaseKey();
+                    LOG.info(message);
+                    throw new KinesisClientLibIOException(message);
+                }
+            }
+        }
+
+        return isCandidateForCleanup;
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisPeriodicShardSyncManager.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisPeriodicShardSyncManager.java
@ -0,0 +1,403 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import com.amazonaws.services.cloudwatch.model.StandardUnit;
+import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
+import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
+import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
+import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
+import com.amazonaws.services.kinesis.leases.impl.HashKeyRangeForLease;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.impl.UpdateField;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
+import com.amazonaws.services.kinesis.metrics.impl.MetricsHelper;
+import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;
+import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
+import com.amazonaws.services.kinesis.model.Shard;
+import com.amazonaws.util.CollectionUtils;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ComparisonChain;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Value;
+import org.apache.commons.lang3.Validate;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import static com.amazonaws.services.kinesis.leases.impl.HashKeyRangeForLease.fromHashKeyRange;
+
+/**
+ * The top level orchestrator for coordinating the periodic shard sync related activities. If the configured
+ * {@link ShardSyncStrategyType} is PERIODIC, this class will be the main shard sync orchestrator. For non-PERIODIC
+ * strategies, this class will serve as an internal auditor that periodically checks if the full hash range is covered
+ * by currently held leases, and initiates a recovery shard sync if not.
+ */
+@Getter
+@EqualsAndHashCode
+class KinesisPeriodicShardSyncManager implements IPeriodicShardSyncManager{
+    private static final Log LOG = LogFactory.getLog(KinesisPeriodicShardSyncManager.class);
+    private static final long INITIAL_DELAY = 0;
+
+    /** DEFAULT interval is used for PERIODIC {@link ShardSyncStrategyType}. */
+
+    private static final long DEFAULT_PERIODIC_SHARD_SYNC_INTERVAL_MILLIS = 1000L;
+
+    /** Parameters for validating hash range completeness when running in auditor mode. */
+    @VisibleForTesting
+    static final BigInteger MIN_HASH_KEY = BigInteger.ZERO;
+    @VisibleForTesting
+    static final BigInteger MAX_HASH_KEY = new BigInteger("2").pow(128).subtract(BigInteger.ONE);
+    static final String PERIODIC_SHARD_SYNC_MANAGER = "PeriodicShardSyncManager";
+    private final HashRangeHoleTracker hashRangeHoleTracker = new HashRangeHoleTracker();
+
+    private final String workerId;
+    private final LeaderDecider leaderDecider;
+    private final ITask metricsEmittingShardSyncTask;
+    private final ScheduledExecutorService shardSyncThreadPool;
+    private final ILeaseManager<KinesisClientLease> leaseManager;
+    private final IKinesisProxy kinesisProxy;
+    private final boolean isAuditorMode;
+    private final long periodicShardSyncIntervalMillis;
+    private boolean isRunning;
+    private final IMetricsFactory metricsFactory;
+    private final int leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+
+
+    KinesisPeriodicShardSyncManager(String workerId,
+                                    LeaderDecider leaderDecider,
+                                    ShardSyncTask shardSyncTask,
+                                    IMetricsFactory metricsFactory,
+                                    ILeaseManager<KinesisClientLease> leaseManager,
+                                    IKinesisProxy kinesisProxy,
+                                    boolean isAuditorMode,
+                                    long leasesRecoveryAuditorExecutionFrequencyMillis,
+                                    int leasesRecoveryAuditorInconsistencyConfidenceThreshold) {
+       this(workerId, leaderDecider, shardSyncTask, Executors.newSingleThreadScheduledExecutor(), metricsFactory,
+            leaseManager, kinesisProxy, isAuditorMode, leasesRecoveryAuditorExecutionFrequencyMillis,
+            leasesRecoveryAuditorInconsistencyConfidenceThreshold);
+    }
+
+    KinesisPeriodicShardSyncManager(String workerId,
+                                    LeaderDecider leaderDecider,
+                                    ShardSyncTask shardSyncTask,
+                                    ScheduledExecutorService shardSyncThreadPool,
+                                    IMetricsFactory metricsFactory,
+                                    ILeaseManager<KinesisClientLease> leaseManager,
+                                    IKinesisProxy kinesisProxy,
+                                    boolean isAuditorMode,
+                                    long leasesRecoveryAuditorExecutionFrequencyMillis,
+                                    int leasesRecoveryAuditorInconsistencyConfidenceThreshold) {
+        Validate.notBlank(workerId, "WorkerID is required to initialize PeriodicShardSyncManager.");
+        Validate.notNull(leaderDecider, "LeaderDecider is required to initialize PeriodicShardSyncManager.");
+        Validate.notNull(shardSyncTask, "ShardSyncTask is required to initialize PeriodicShardSyncManager.");
+        this.workerId = workerId;
+        this.leaderDecider = leaderDecider;
+        this.metricsEmittingShardSyncTask = new MetricsCollectingTaskDecorator(shardSyncTask, metricsFactory);
+        this.shardSyncThreadPool = shardSyncThreadPool;
+        this.leaseManager = leaseManager;
+        this.kinesisProxy = kinesisProxy;
+        this.metricsFactory = metricsFactory;
+        this.isAuditorMode = isAuditorMode;
+        this.leasesRecoveryAuditorInconsistencyConfidenceThreshold = leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+        if (isAuditorMode) {
+            Validate.notNull(this.leaseManager, "LeaseManager is required for non-PERIODIC shard sync strategies.");
+            Validate.notNull(this.kinesisProxy, "KinesisProxy is required for non-PERIODIC shard sync strategies.");
+            this.periodicShardSyncIntervalMillis = leasesRecoveryAuditorExecutionFrequencyMillis;
+        } else {
+            this.periodicShardSyncIntervalMillis = DEFAULT_PERIODIC_SHARD_SYNC_INTERVAL_MILLIS;
+        }
+    }
+
+    @Override
+    public synchronized TaskResult start() {
+        if (!isRunning) {
+            final Runnable periodicShardSyncer = () -> {
+                try {
+                    runShardSync();
+                } catch (Throwable t) {
+                    LOG.error("Error running shard sync.", t);
+                }
+            };
+
+            shardSyncThreadPool
+                    .scheduleWithFixedDelay(periodicShardSyncer, INITIAL_DELAY, periodicShardSyncIntervalMillis,
+                            TimeUnit.MILLISECONDS);
+            isRunning = true;
+        }
+        return new TaskResult(null);
+    }
+
+    /**
+     * Runs ShardSync once, without scheduling further periodic ShardSyncs.
+     * @return TaskResult from shard sync
+     */
+    @Override
+    public synchronized TaskResult syncShardsOnce() {
+        LOG.info("Syncing shards once from worker " + workerId);
+        return metricsEmittingShardSyncTask.call();
+    }
+
+    @Override
+    public void stop() {
+        if (isRunning) {
+            LOG.info(String.format("Shutting down leader decider on worker %s", workerId));
+            leaderDecider.shutdown();
+            LOG.info(String.format("Shutting down periodic shard sync task scheduler on worker %s", workerId));
+            shardSyncThreadPool.shutdown();
+            isRunning = false;
+        }
+    }
+
+    private void runShardSync() {
+        if (leaderDecider.isLeader(workerId)) {
+            LOG.debug("WorkerId " + workerId + " is a leader, running the shard sync task");
+
+            MetricsHelper.startScope(metricsFactory, PERIODIC_SHARD_SYNC_MANAGER);
+            boolean isRunSuccess = false;
+            final long runStartMillis = System.currentTimeMillis();
+
+            try {
+                final ShardSyncResponse shardSyncResponse = checkForShardSync();
+                MetricsHelper.getMetricsScope().addData("NumStreamsToSync", shardSyncResponse.shouldDoShardSync() ? 1 : 0, StandardUnit.Count, MetricsLevel.SUMMARY);
+                MetricsHelper.getMetricsScope().addData("NumStreamsWithPartialLeases", shardSyncResponse.isHoleDetected() ? 1 : 0, StandardUnit.Count, MetricsLevel.SUMMARY);
+                if (shardSyncResponse.shouldDoShardSync()) {
+                    LOG.info("Periodic shard syncer initiating shard sync due to the reason - " +
+                            shardSyncResponse.reasonForDecision());
+                    metricsEmittingShardSyncTask.call();
+                } else {
+                    LOG.info("Skipping shard sync due to the reason - " + shardSyncResponse.reasonForDecision());
+                }
+                isRunSuccess = true;
+            } catch (Exception e) {
+                LOG.error("Caught exception while running periodic shard syncer.", e);
+            } finally {
+                MetricsHelper.addSuccessAndLatency(runStartMillis, isRunSuccess, MetricsLevel.SUMMARY);
+                MetricsHelper.endScope();
+            }
+        } else {
+            LOG.debug("WorkerId " + workerId + " is not a leader, not running the shard sync task");
+        }
+    }
+
+    @VisibleForTesting
+    ShardSyncResponse checkForShardSync() throws DependencyException, InvalidStateException,
+            ProvisionedThroughputException {
+
+        if (!isAuditorMode) {
+            // If we are running with PERIODIC shard sync strategy, we should sync every time.
+            return new ShardSyncResponse(true, false, "Syncing every time with PERIODIC shard sync strategy.");
+        }
+
+        // Get current leases from DynamoDB.
+        final List<KinesisClientLease> currentLeases = leaseManager.listLeases();
+
+        if (CollectionUtils.isNullOrEmpty(currentLeases)) {
+            // If the current leases are null or empty, then we need to initiate a shard sync.
+            LOG.info("No leases found. Will trigger a shard sync.");
+            return new ShardSyncResponse(true, false, "No leases found.");
+        }
+
+        // Check if there are any holes in the hash range covered by current leases. Return the first hole if present.
+        Optional<HashRangeHole> hashRangeHoleOpt = hasHoleInLeases(currentLeases);
+        if (hashRangeHoleOpt.isPresent()) {
+            // If hole is present, check if the hole is detected consecutively in previous occurrences. If hole is
+            // determined with high confidence, return true; return false otherwise. We use the high confidence factor
+            // to avoid shard sync on any holes during resharding and lease cleanups, or other intermittent issues.
+            final boolean hasHoleWithHighConfidence =
+                    hashRangeHoleTracker.hashHighConfidenceOfHoleWith(hashRangeHoleOpt.get());
+
+            return new ShardSyncResponse(hasHoleWithHighConfidence, true,
+                    "Detected the same hole for " + hashRangeHoleTracker.getNumConsecutiveHoles() + " times. " +
+                    "Will initiate shard sync after reaching threshold: " + leasesRecoveryAuditorInconsistencyConfidenceThreshold);
+        } else {
+            // If hole is not present, clear any previous hole tracking and return false.
+            hashRangeHoleTracker.reset();
+            return new ShardSyncResponse(false, false, "Hash range is complete.");
+        }
+    }
+
+    @VisibleForTesting
+    Optional<HashRangeHole> hasHoleInLeases(List<KinesisClientLease> leases) {
+        // Filter out any leases with checkpoints other than SHARD_END
+        final List<KinesisClientLease> activeLeases = leases.stream()
+                .filter(lease -> lease.getCheckpoint() != null && !lease.getCheckpoint().isShardEnd())
+                .collect(Collectors.toList());
+
+        final List<KinesisClientLease> activeLeasesWithHashRanges = fillWithHashRangesIfRequired(activeLeases);
+        return checkForHoleInHashKeyRanges(activeLeasesWithHashRanges);
+    }
+
+    private List<KinesisClientLease> fillWithHashRangesIfRequired(List<KinesisClientLease> activeLeases) {
+        final List<KinesisClientLease> activeLeasesWithNoHashRanges = activeLeases.stream()
+                .filter(lease -> lease.getHashKeyRange() == null).collect(Collectors.toList());
+
+        if (activeLeasesWithNoHashRanges.isEmpty()) {
+            return activeLeases;
+        }
+
+        // Fetch shards from Kinesis to fill in the in-memory hash ranges
+        final Map<String, Shard> kinesisShards = kinesisProxy.getShardList().stream()
+                .collect(Collectors.toMap(Shard::getShardId, shard -> shard));
+
+        return activeLeases.stream().map(lease -> {
+            if (lease.getHashKeyRange() == null) {
+                final String shardId = lease.getLeaseKey();
+                final Shard shard = kinesisShards.get(shardId);
+                if (shard == null) {
+                    return lease;
+                }
+                lease.setHashKeyRange(fromHashKeyRange(shard.getHashKeyRange()));
+
+                try {
+                    leaseManager.updateLeaseWithMetaInfo(lease, UpdateField.HASH_KEY_RANGE);
+                } catch (Exception e) {
+                    LOG.warn("Unable to update hash range information for lease " + lease.getLeaseKey() +
+                            ". This may result in explicit lease sync.");
+                }
+            }
+            return lease;
+        }).filter(lease -> lease.getHashKeyRange() != null).collect(Collectors.toList());
+    }
+
+    @VisibleForTesting
+    static Optional<HashRangeHole> checkForHoleInHashKeyRanges(List<KinesisClientLease> leasesWithHashKeyRanges) {
+        // Sort the hash ranges by starting hash key
+        final List<KinesisClientLease> sortedLeasesWithHashKeyRanges = sortLeasesByHashRange(leasesWithHashKeyRanges);
+        if (sortedLeasesWithHashKeyRanges.isEmpty()) {
+            LOG.error("No leases with valid hash ranges found.");
+            return Optional.of(new HashRangeHole());
+        }
+
+        // Validate the hash range bounds
+        final KinesisClientLease minHashKeyLease = sortedLeasesWithHashKeyRanges.get(0);
+        final KinesisClientLease maxHashKeyLease =
+                sortedLeasesWithHashKeyRanges.get(sortedLeasesWithHashKeyRanges.size() - 1);
+        if (!minHashKeyLease.getHashKeyRange().startingHashKey().equals(MIN_HASH_KEY) ||
+            !maxHashKeyLease.getHashKeyRange().endingHashKey().equals(MAX_HASH_KEY)) {
+            LOG.error("Incomplete hash range found between " + minHashKeyLease + " and " + maxHashKeyLease);
+            return Optional.of(new HashRangeHole(minHashKeyLease.getHashKeyRange(), maxHashKeyLease.getHashKeyRange()));
+        }
+
+        // Check for any holes in the sorted hash range intervals
+        if (sortedLeasesWithHashKeyRanges.size() > 1) {
+            KinesisClientLease leftmostLeaseToReportInCaseOfHole = minHashKeyLease;
+            HashKeyRangeForLease leftLeaseHashRange = leftmostLeaseToReportInCaseOfHole.getHashKeyRange();
+
+            for (int i = 1; i < sortedLeasesWithHashKeyRanges.size(); i++) {
+                final KinesisClientLease rightLease = sortedLeasesWithHashKeyRanges.get(i);
+                final HashKeyRangeForLease rightLeaseHashRange = rightLease.getHashKeyRange();
+                final BigInteger rangeDiff =
+                        rightLeaseHashRange.startingHashKey().subtract(leftLeaseHashRange.endingHashKey());
+                // We have overlapping leases when rangeDiff is 0 or negative.
+                // signum() will be -1 for negative and 0 if value is 0.
+                // Merge the ranges for further tracking.
+                if (rangeDiff.signum() <= 0) {
+                    leftLeaseHashRange = new HashKeyRangeForLease(leftLeaseHashRange.startingHashKey(),
+                            leftLeaseHashRange.endingHashKey().max(rightLeaseHashRange.endingHashKey()));
+                } else {
+                    // We have non-overlapping leases when rangeDiff is positive. signum() will be 1 in this case.
+                    // If rangeDiff is 1, then it is a continuous hash range. If not, there is a hole.
+                    if (!rangeDiff.equals(BigInteger.ONE)) {
+                        LOG.error("Incomplete hash range found between " + leftmostLeaseToReportInCaseOfHole +
+                                " and " + rightLease);
+                        return Optional.of(new HashRangeHole(leftmostLeaseToReportInCaseOfHole.getHashKeyRange(),
+                                rightLease.getHashKeyRange()));
+                    }
+
+                    leftmostLeaseToReportInCaseOfHole = rightLease;
+                    leftLeaseHashRange = rightLeaseHashRange;
+                }
+            }
+        }
+
+        return Optional.empty();
+    }
+
+    @VisibleForTesting
+    static List<KinesisClientLease> sortLeasesByHashRange(List<KinesisClientLease> leasesWithHashKeyRanges) {
+        if (leasesWithHashKeyRanges.size() == 0 || leasesWithHashKeyRanges.size() == 1) {
+            return leasesWithHashKeyRanges;
+        }
+        Collections.sort(leasesWithHashKeyRanges, new HashKeyRangeComparator());
+        return leasesWithHashKeyRanges;
+    }
+    @Value
+    private static class HashRangeHole {
+        private final HashKeyRangeForLease hashRangeAtStartOfPossibleHole;
+        private final HashKeyRangeForLease hashRangeAtEndOfPossibleHole;
+
+        HashRangeHole() {
+            hashRangeAtStartOfPossibleHole = hashRangeAtEndOfPossibleHole = null;
+        }
+
+        HashRangeHole(HashKeyRangeForLease hashRangeAtStartOfPossibleHole,
+                      HashKeyRangeForLease hashRangeAtEndOfPossibleHole) {
+            this.hashRangeAtStartOfPossibleHole = hashRangeAtStartOfPossibleHole;
+            this.hashRangeAtEndOfPossibleHole = hashRangeAtEndOfPossibleHole;
+        }
+    }
+
+    private class HashRangeHoleTracker {
+        private HashRangeHole hashRangeHole;
+        @Getter
+        private Integer numConsecutiveHoles;
+
+        public boolean hashHighConfidenceOfHoleWith(@NonNull HashRangeHole hashRangeHole) {
+            if (hashRangeHole.equals(this.hashRangeHole)) {
+                ++this.numConsecutiveHoles;
+            } else {
+                this.hashRangeHole = hashRangeHole;
+                this.numConsecutiveHoles = 1;
+            }
+
+            return numConsecutiveHoles >= leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+        }
+
+        public void reset() {
+            this.hashRangeHole = null;
+            this.numConsecutiveHoles = 0;
+        }
+    }
+
+    private static class HashKeyRangeComparator implements Comparator<KinesisClientLease>, Serializable {
+        private static final long serialVersionUID = 1L;
+
+        @Override
+        public int compare(KinesisClientLease lease, KinesisClientLease otherLease) {
+            Validate.notNull(lease);
+            Validate.notNull(otherLease);
+            Validate.notNull(lease.getHashKeyRange());
+            Validate.notNull(otherLease.getHashKeyRange());
+            return ComparisonChain.start()
+                    .compare(lease.getHashKeyRange().startingHashKey(), otherLease.getHashKeyRange().startingHashKey())
+                    .compare(lease.getHashKeyRange().endingHashKey(), otherLease.getHashKeyRange().endingHashKey())
+                    .result();
+        }
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShardConsumer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShardConsumer.java
@ -1,25 +1,29 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

-
+import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;

+import com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager;
+import com.amazonaws.services.kinesis.model.ChildShard;
+import com.amazonaws.util.CollectionUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

@ -30,7 +34,6 @@ import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
 import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
 import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;
 import com.google.common.annotations.VisibleForTesting;
-
 import lombok.Getter;

 /**
@ -38,9 +41,9 @@ import lombok.Getter;
 * The instance should be shutdown when we lose the primary responsibility for a shard.
 * A new instance should be created if the primary responsibility is reassigned back to this process.
 */
-class ShardConsumer {
+public class KinesisShardConsumer implements IShardConsumer{

-    private static final Log LOG = LogFactory.getLog(ShardConsumer.class);
+    private static final Log LOG = LogFactory.getLog(KinesisShardConsumer.class);

    private final StreamConfig streamConfig;
    private final IRecordProcessor recordProcessor;
@ -50,25 +53,33 @@ class ShardConsumer {
    private final ShardInfo shardInfo;
    private final KinesisDataFetcher dataFetcher;
    private final IMetricsFactory metricsFactory;
-    private final ILeaseManager<KinesisClientLease> leaseManager;
+    private final KinesisClientLibLeaseCoordinator leaseCoordinator;
    private ICheckpoint checkpoint;
+    private LeaseCleanupManager leaseCleanupManager;
    // Backoff time when polling to check if application has finished processing parent shards
    private final long parentShardPollIntervalMillis;
    private final boolean cleanupLeasesOfCompletedShards;
    private final long taskBackoffTimeMillis;
    private final boolean skipShardSyncAtWorkerInitializationIfLeasesExist;

+    @Getter
+    private final ShardSyncer shardSyncer;
+
    private ITask currentTask;
    private long currentTaskSubmitTime;
    private Future<TaskResult> future;
-    
+    private ShardSyncStrategy shardSyncStrategy;
+
+    @Getter
+    private List<ChildShard> childShards;
+
    @Getter
    private final GetRecordsCache getRecordsCache;

-    private static final GetRecordsRetrievalStrategy makeStrategy(KinesisDataFetcher dataFetcher,
-                                                                  Optional<Integer> retryGetRecordsInSeconds,
-                                                                  Optional<Integer> maxGetRecordsThreadPool,
-                                                                  ShardInfo shardInfo) {
+    private static final GetRecordsRetrievalStrategy makeStrategy(IDataFetcher dataFetcher,
+            Optional<Integer> retryGetRecordsInSeconds,
+            Optional<Integer> maxGetRecordsThreadPool,
+            ShardInfo shardInfo) {
        Optional<GetRecordsRetrievalStrategy> getRecordsRetrievalStrategy = retryGetRecordsInSeconds.flatMap(retry ->
                maxGetRecordsThreadPool.map(max ->
                        new AsynchronousGetRecordsRetrievalStrategy(dataFetcher, retry, max, shardInfo.getShardId())));
@ -80,7 +91,7 @@ class ShardConsumer {
     * Tracks current state. It is only updated via the consumeStream/shutdown APIs. Therefore we don't do
     * much coordination/synchronization to handle concurrent reads/updates.
     */
-    private ConsumerStates.ConsumerState currentState = ConsumerStates.INITIAL_STATE;
+    private KinesisConsumerStates.ConsumerState currentState = KinesisConsumerStates.INITIAL_STATE;
    /*
     * Used to track if we lost the primary responsibility. Once set to true, we will start shutting down.
     * If we regain primary responsibility before shutdown is complete, Worker should create a new ShardConsumer object.
@ -94,30 +105,33 @@ class ShardConsumer {
     * @param checkpoint Checkpoint tracker
     * @param recordProcessor Record processor used to process the data records for the shard
     * @param config Kinesis library configuration
-     * @param leaseManager Used to create leases for new shards
+     * @param leaseCoordinator Used to manage leases for current worker
     * @param parentShardPollIntervalMillis Wait for this long if parent shards are not done (or we get an exception)
     * @param executorService ExecutorService used to execute process tasks for this shard
     * @param metricsFactory IMetricsFactory used to construct IMetricsScopes for this shard
     * @param backoffTimeMillis backoff interval when we encounter exceptions
+     * @param shardSyncer shardSyncer instance used to check and create new leases
     */
    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 10 LINES
-    ShardConsumer(ShardInfo shardInfo,
-                  StreamConfig streamConfig,
-                  ICheckpoint checkpoint,
-                  IRecordProcessor recordProcessor,
-                  ILeaseManager<KinesisClientLease> leaseManager,
-                  long parentShardPollIntervalMillis,
-                  boolean cleanupLeasesOfCompletedShards,
-                  ExecutorService executorService,
-                  IMetricsFactory metricsFactory,
-                  long backoffTimeMillis,
-                  boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
-                  KinesisClientLibConfiguration config) {
+    @Deprecated
+    KinesisShardConsumer(ShardInfo shardInfo,
+            StreamConfig streamConfig,
+            ICheckpoint checkpoint,
+            IRecordProcessor recordProcessor,
+            KinesisClientLibLeaseCoordinator leaseCoordinator,
+            long parentShardPollIntervalMillis,
+            boolean cleanupLeasesOfCompletedShards,
+            ExecutorService executorService,
+            IMetricsFactory metricsFactory,
+            long backoffTimeMillis,
+            boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
+            KinesisClientLibConfiguration config, ShardSyncer shardSyncer, ShardSyncStrategy shardSyncStrategy) {
+
        this(shardInfo,
                streamConfig,
                checkpoint,
                recordProcessor,
-                leaseManager,
+                leaseCoordinator,
                parentShardPollIntervalMillis,
                cleanupLeasesOfCompletedShards,
                executorService,
@ -126,7 +140,7 @@ class ShardConsumer {
                skipShardSyncAtWorkerInitializationIfLeasesExist,
                Optional.empty(),
                Optional.empty(),
-                config);
+                config, shardSyncer, shardSyncStrategy);
    }

    /**
@ -134,7 +148,7 @@ class ShardConsumer {
     * @param streamConfig Stream configuration to use
     * @param checkpoint Checkpoint tracker
     * @param recordProcessor Record processor used to process the data records for the shard
-     * @param leaseManager Used to create leases for new shards
+     * @param leaseCoordinator Used to manage leases for current worker
     * @param parentShardPollIntervalMillis Wait for this long if parent shards are not done (or we get an exception)
     * @param executorService ExecutorService used to execute process tasks for this shard
     * @param metricsFactory IMetricsFactory used to construct IMetricsScopes for this shard
@ -142,23 +156,24 @@ class ShardConsumer {
     * @param retryGetRecordsInSeconds time in seconds to wait before the worker retries to get a record.
     * @param maxGetRecordsThreadPool max number of threads in the getRecords thread pool.
     * @param config Kinesis library configuration
+     * @param shardSyncer shardSyncer instance used to check and create new leases
     */
    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 10 LINES
-    ShardConsumer(ShardInfo shardInfo,
-                  StreamConfig streamConfig,
-                  ICheckpoint checkpoint,
-                  IRecordProcessor recordProcessor,
-                  ILeaseManager<KinesisClientLease> leaseManager,
-                  long parentShardPollIntervalMillis,
-                  boolean cleanupLeasesOfCompletedShards,
-                  ExecutorService executorService,
-                  IMetricsFactory metricsFactory,
-                  long backoffTimeMillis,
-                  boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
-                  Optional<Integer> retryGetRecordsInSeconds,
-                  Optional<Integer> maxGetRecordsThreadPool,
-                  KinesisClientLibConfiguration config) {
-        
+    @Deprecated
+    KinesisShardConsumer(ShardInfo shardInfo,
+            StreamConfig streamConfig,
+            ICheckpoint checkpoint,
+            IRecordProcessor recordProcessor,
+            KinesisClientLibLeaseCoordinator leaseCoordinator,
+            long parentShardPollIntervalMillis,
+            boolean cleanupLeasesOfCompletedShards,
+            ExecutorService executorService,
+            IMetricsFactory metricsFactory,
+            long backoffTimeMillis,
+            boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
+            Optional<Integer> retryGetRecordsInSeconds,
+            Optional<Integer> maxGetRecordsThreadPool,
+            KinesisClientLibConfiguration config, ShardSyncer shardSyncer, ShardSyncStrategy shardSyncStrategy) {
        this(
                shardInfo,
                streamConfig,
@ -170,9 +185,8 @@ class ShardConsumer {
                        new SequenceNumberValidator(
                                streamConfig.getStreamProxy(),
                                shardInfo.getShardId(),
-                                streamConfig.shouldValidateSequenceNumberBeforeCheckpointing()),
-                        metricsFactory),
-                leaseManager,
+                                streamConfig.shouldValidateSequenceNumberBeforeCheckpointing())),
+                leaseCoordinator,
                parentShardPollIntervalMillis,
                cleanupLeasesOfCompletedShards,
                executorService,
@ -182,7 +196,7 @@ class ShardConsumer {
                new KinesisDataFetcher(streamConfig.getStreamProxy(), shardInfo),
                retryGetRecordsInSeconds,
                maxGetRecordsThreadPool,
-                config
+                config, shardSyncer, shardSyncStrategy
        );
    }

@ -192,7 +206,7 @@ class ShardConsumer {
     * @param checkpoint Checkpoint tracker
     * @param recordProcessor Record processor used to process the data records for the shard
     * @param recordProcessorCheckpointer RecordProcessorCheckpointer to use to checkpoint progress
-     * @param leaseManager Used to create leases for new shards
+     * @param leaseCoordinator Used to manage leases for current worker
     * @param parentShardPollIntervalMillis Wait for this long if parent shards are not done (or we get an exception)
     * @param cleanupLeasesOfCompletedShards  clean up the leases of completed shards
     * @param executorService ExecutorService used to execute process tasks for this shard
@ -203,29 +217,78 @@ class ShardConsumer {
     * @param retryGetRecordsInSeconds time in seconds to wait before the worker retries to get a record
     * @param maxGetRecordsThreadPool max number of threads in the getRecords thread pool
     * @param config Kinesis library configuration
+     * @param shardSyncer shardSyncer instance used to check and create new leases
     */
-    ShardConsumer(ShardInfo shardInfo,
-                  StreamConfig streamConfig,
-                  ICheckpoint checkpoint,
-                  IRecordProcessor recordProcessor,
-                  RecordProcessorCheckpointer recordProcessorCheckpointer,
-                  ILeaseManager<KinesisClientLease> leaseManager,
-                  long parentShardPollIntervalMillis,
-                  boolean cleanupLeasesOfCompletedShards,
-                  ExecutorService executorService,
-                  IMetricsFactory metricsFactory,
-                  long backoffTimeMillis,
-                  boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
-                  KinesisDataFetcher kinesisDataFetcher,
-                  Optional<Integer> retryGetRecordsInSeconds,
-                  Optional<Integer> maxGetRecordsThreadPool,
-                  KinesisClientLibConfiguration config) {
+    @Deprecated
+    KinesisShardConsumer(ShardInfo shardInfo,
+            StreamConfig streamConfig,
+            ICheckpoint checkpoint,
+            IRecordProcessor recordProcessor,
+            RecordProcessorCheckpointer recordProcessorCheckpointer,
+            KinesisClientLibLeaseCoordinator leaseCoordinator,
+            long parentShardPollIntervalMillis,
+            boolean cleanupLeasesOfCompletedShards,
+            ExecutorService executorService,
+            IMetricsFactory metricsFactory,
+            long backoffTimeMillis,
+            boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
+            KinesisDataFetcher kinesisDataFetcher,
+            Optional<Integer> retryGetRecordsInSeconds,
+            Optional<Integer> maxGetRecordsThreadPool,
+            KinesisClientLibConfiguration config, ShardSyncer shardSyncer, ShardSyncStrategy shardSyncStrategy) {
+
+        this(shardInfo, streamConfig, checkpoint, recordProcessor, recordProcessorCheckpointer, leaseCoordinator,
+        parentShardPollIntervalMillis, cleanupLeasesOfCompletedShards, executorService, metricsFactory,
+        backoffTimeMillis, skipShardSyncAtWorkerInitializationIfLeasesExist, kinesisDataFetcher, retryGetRecordsInSeconds,
+        maxGetRecordsThreadPool, config, shardSyncer, shardSyncStrategy, LeaseCleanupManager.newInstance(streamConfig.getStreamProxy(), leaseCoordinator.getLeaseManager(),
+                Executors.newSingleThreadScheduledExecutor(), metricsFactory, config.shouldCleanupLeasesUponShardCompletion(),
+                config.leaseCleanupIntervalMillis(), config.completedLeaseCleanupThresholdMillis(),
+                config.garbageLeaseCleanupThresholdMillis(), config.getMaxRecords()));
+    }
+
+    /**
+     * @param shardInfo Shard information
+     * @param streamConfig Stream Config to use
+     * @param checkpoint Checkpoint tracker
+     * @param recordProcessor Record processor used to process the data records for the shard
+     * @param recordProcessorCheckpointer RecordProcessorCheckpointer to use to checkpoint progress
+     * @param leaseCoordinator Used to manage leases for current worker
+     * @param parentShardPollIntervalMillis Wait for this long if parent shards are not done (or we get an exception)
+     * @param cleanupLeasesOfCompletedShards  clean up the leases of completed shards
+     * @param executorService ExecutorService used to execute process tasks for this shard
+     * @param metricsFactory IMetricsFactory used to construct IMetricsScopes for this shard
+     * @param backoffTimeMillis backoff interval when we encounter exceptions
+     * @param skipShardSyncAtWorkerInitializationIfLeasesExist Skip sync at init if lease exists
+     * @param kinesisDataFetcher KinesisDataFetcher to fetch data from Kinesis streams.
+     * @param retryGetRecordsInSeconds time in seconds to wait before the worker retries to get a record
+     * @param maxGetRecordsThreadPool max number of threads in the getRecords thread pool
+     * @param config Kinesis library configuration
+     * @param shardSyncer shardSyncer instance used to check and create new leases
+     * @param leaseCleanupManager used to clean up leases in lease table.
+     */
+    KinesisShardConsumer(ShardInfo shardInfo,
+            StreamConfig streamConfig,
+            ICheckpoint checkpoint,
+            IRecordProcessor recordProcessor,
+            RecordProcessorCheckpointer recordProcessorCheckpointer,
+            KinesisClientLibLeaseCoordinator leaseCoordinator,
+            long parentShardPollIntervalMillis,
+            boolean cleanupLeasesOfCompletedShards,
+            ExecutorService executorService,
+            IMetricsFactory metricsFactory,
+            long backoffTimeMillis,
+            boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
+            KinesisDataFetcher kinesisDataFetcher,
+            Optional<Integer> retryGetRecordsInSeconds,
+            Optional<Integer> maxGetRecordsThreadPool,
+            KinesisClientLibConfiguration config, ShardSyncer shardSyncer, ShardSyncStrategy shardSyncStrategy,
+            LeaseCleanupManager leaseCleanupManager) {
        this.shardInfo = shardInfo;
        this.streamConfig = streamConfig;
        this.checkpoint = checkpoint;
        this.recordProcessor = recordProcessor;
        this.recordProcessorCheckpointer = recordProcessorCheckpointer;
-        this.leaseManager = leaseManager;
+        this.leaseCoordinator = leaseCoordinator;
        this.parentShardPollIntervalMillis = parentShardPollIntervalMillis;
        this.cleanupLeasesOfCompletedShards = cleanupLeasesOfCompletedShards;
        this.executorService = executorService;
@ -237,15 +300,18 @@ class ShardConsumer {
        this.getRecordsCache = config.getRecordsFetcherFactory().createRecordsFetcher(
                makeStrategy(this.dataFetcher, retryGetRecordsInSeconds, maxGetRecordsThreadPool, this.shardInfo),
                this.getShardInfo().getShardId(), this.metricsFactory, this.config.getMaxRecords());
+        this.shardSyncer = shardSyncer;
+        this.shardSyncStrategy = shardSyncStrategy;
+        this.leaseCleanupManager = leaseCleanupManager;
    }

    /**
     * No-op if current task is pending, otherwise submits next task for this shard.
     * This method should NOT be called if the ShardConsumer is already in SHUTDOWN_COMPLETED state.
-     * 
+     *
     * @return true if a new process task was submitted, false otherwise
     */
-    synchronized boolean consumeShard() {
+    public synchronized boolean consumeShard() {
        return checkAndSubmitNextTask();
    }

@ -304,20 +370,24 @@ class ShardConsumer {
        return skipShardSyncAtWorkerInitializationIfLeasesExist;
    }

-    private enum TaskOutcome {
-        SUCCESSFUL, END_OF_SHARD, NOT_COMPLETE, FAILURE
-    }
-
    private TaskOutcome determineTaskOutcome() {
        try {
            TaskResult result = future.get();
            if (result.getException() == null) {
                if (result.isShardEndReached()) {
+                    if (!CollectionUtils.isNullOrEmpty(result.getChildShards())) {
+                        childShards = result.getChildShards();
+                        LOG.info("Shard " + shardInfo.getShardId() + ": Setting childShards in ShardConsumer: " + childShards);
+                    }
                    return TaskOutcome.END_OF_SHARD;
                }
                return TaskOutcome.SUCCESSFUL;
            }
            logTaskException(result);
+            // This is the case of result with exception
+            if (result.isLeaseNotFound()) {
+                return TaskOutcome.LEASE_NOT_FOUND;
+            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
@ -343,10 +413,10 @@ class ShardConsumer {
    /**
     * Requests the shutdown of the this ShardConsumer. This should give the record processor a chance to checkpoint
     * before being shutdown.
-     * 
+     *
     * @param shutdownNotification used to signal that the record processor has been given the chance to shutdown.
     */
-    void notifyShutdownRequested(ShutdownNotification shutdownNotification) {
+    public void notifyShutdownRequested(ShutdownNotification shutdownNotification) {
        this.shutdownNotification = shutdownNotification;
        markForShutdown(ShutdownReason.REQUESTED);
    }
@ -354,10 +424,10 @@ class ShardConsumer {
    /**
     * Shutdown this ShardConsumer (including invoking the RecordProcessor shutdown API).
     * This is called by Worker when it loses responsibility for a shard.
-     * 
+     *
     * @return true if shutdown is complete (false if shutdown is still in progress)
     */
-    synchronized boolean beginShutdown() {
+    public synchronized boolean beginShutdown() {
        markForShutdown(ShutdownReason.ZOMBIE);
        checkAndSubmitNextTask();

@ -374,23 +444,23 @@ class ShardConsumer {
    /**
     * Used (by Worker) to check if this ShardConsumer instance has been shutdown
     * RecordProcessor shutdown() has been invoked, as appropriate.
-     * 
+     *
     * @return true if shutdown is complete
     */
-    boolean isShutdown() {
+    public boolean isShutdown() {
        return currentState.isTerminal();
    }

    /**
     * @return the shutdownReason
     */
-    ShutdownReason getShutdownReason() {
+    public ShutdownReason getShutdownReason() {
        return shutdownReason;
    }

    /**
     * Figure out next task to run based on current state, task, and shutdown context.
-     * 
+     *
     * @return Return next task to run
     */
    private ITask getNextTask() {
@ -406,15 +476,22 @@ class ShardConsumer {
    /**
     * Note: This is a private/internal method with package level access solely for testing purposes.
     * Update state based on information about: task success, current state, and shutdown info.
-     * 
+     *
     * @param taskOutcome The outcome of the last task
     */
    void updateState(TaskOutcome taskOutcome) {
        if (taskOutcome == TaskOutcome.END_OF_SHARD) {
            markForShutdown(ShutdownReason.TERMINATE);
+            LOG.info("Shard " + shardInfo.getShardId() + ": Mark for shutdown with reason TERMINATE");
+        }
+        if (taskOutcome == TaskOutcome.LEASE_NOT_FOUND) {
+            markForShutdown(ShutdownReason.ZOMBIE);
+            LOG.info("Shard " + shardInfo.getShardId() + ": Mark for shutdown with reason ZOMBIE as lease was not found");
        }
        if (isShutdownRequested() && taskOutcome != TaskOutcome.FAILURE) {
            currentState = currentState.shutdownTransition(shutdownReason);
+        } else if (isShutdownRequested() && KinesisConsumerStates.ShardConsumerState.WAITING_ON_PARENT_SHARDS.equals(currentState.getState())) {
+            currentState = currentState.shutdownTransition(shutdownReason);
        } else if (taskOutcome == TaskOutcome.SUCCESSFUL) {
            if (currentState.getTaskType() == currentTask.getTaskType()) {
                currentState = currentState.successTransition();
@ -432,16 +509,16 @@ class ShardConsumer {
    }

    @VisibleForTesting
-    boolean isShutdownRequested() {
+    public boolean isShutdownRequested() {
        return shutdownReason != null;
    }

    /**
     * Private/Internal method - has package level access solely for testing purposes.
-     * 
+     *
     * @return the currentState
     */
-    ConsumerStates.ShardConsumerState getCurrentState() {
+    public KinesisConsumerStates.ShardConsumerState getCurrentState() {
        return currentState.getState();
    }

@ -470,7 +547,11 @@ class ShardConsumer {
    }

    ILeaseManager<KinesisClientLease> getLeaseManager() {
-        return leaseManager;
+        return leaseCoordinator.getLeaseManager();
+    }
+
+    KinesisClientLibLeaseCoordinator getLeaseCoordinator() {
+        return leaseCoordinator;
    }

    ICheckpoint getCheckpoint() {
@ -500,4 +581,12 @@ class ShardConsumer {
    ShutdownNotification getShutdownNotification() {
        return shutdownNotification;
    }
+
+    ShardSyncStrategy getShardSyncStrategy() {
+        return shardSyncStrategy;
+    }
+
+    LeaseCleanupManager getLeaseCleanupManager() {
+        return leaseCleanupManager;
+    }
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShardConsumerFactory.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShardConsumerFactory.java
@ -0,0 +1,48 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.interfaces.ICheckpoint;
+import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessor;
+import com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager;
+import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;
+
+import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+
+public class KinesisShardConsumerFactory implements IShardConsumerFactory{
+
+    @Override
+    public IShardConsumer createShardConsumer(ShardInfo shardInfo,
+                                              StreamConfig streamConfig,
+                                              ICheckpoint checkpointTracker,
+                                              IRecordProcessor recordProcessor,
+                                              RecordProcessorCheckpointer recordProcessorCheckpointer,
+                                              KinesisClientLibLeaseCoordinator leaseCoordinator,
+                                              long parentShardPollIntervalMillis,
+                                              boolean cleanupLeasesUponShardCompletion,
+                                              ExecutorService executorService,
+                                              IMetricsFactory metricsFactory,
+                                              long taskBackoffTimeMillis,
+                                              boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
+                                              Optional<Integer> retryGetRecordsInSeconds,
+                                              Optional<Integer> maxGetRecordsThreadPool,
+                                              KinesisClientLibConfiguration config, ShardSyncer shardSyncer, ShardSyncStrategy shardSyncStrategy,
+                                              LeaseCleanupManager leaseCleanupManager) {
+        return new KinesisShardConsumer(shardInfo,
+                streamConfig,
+                checkpointTracker,
+                recordProcessor,
+                recordProcessorCheckpointer,
+                leaseCoordinator,
+                parentShardPollIntervalMillis,
+                cleanupLeasesUponShardCompletion,
+                executorService,
+                metricsFactory,
+                taskBackoffTimeMillis,
+                skipShardSyncAtWorkerInitializationIfLeasesExist,
+                new KinesisDataFetcher(streamConfig.getStreamProxy(), shardInfo),
+                retryGetRecordsInSeconds,
+                maxGetRecordsThreadPool,
+                config, shardSyncer, shardSyncStrategy,
+                leaseCleanupManager);
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShardSyncer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShardSyncer.java
@ -0,0 +1,773 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.amazonaws.services.kinesis.model.ChildShard;
+import com.amazonaws.services.kinesis.model.ShardFilter;
+import com.amazonaws.services.kinesis.model.ShardFilterType;
+import com.amazonaws.util.CollectionUtils;
+import lombok.NoArgsConstructor;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.commons.lang3.StringUtils;
+
+import com.amazonaws.services.kinesis.clientlibrary.exceptions.internal.KinesisClientLibIOException;
+import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
+import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;
+import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
+import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
+import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
+import com.amazonaws.services.kinesis.metrics.impl.MetricsHelper;
+import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
+import com.amazonaws.services.kinesis.model.Shard;
+
+import static com.amazonaws.services.kinesis.leases.impl.HashKeyRangeForLease.fromHashKeyRange;
+
+/**
+ * Helper class to sync leases with shards of the Kinesis stream.
+ * It will create new leases/activities when it discovers new Kinesis shards (bootstrap/resharding).
+ * It deletes leases for shards that have been trimmed from Kinesis, or if we've completed processing it
+ * and begun processing it's child shards.
+ */
+class KinesisShardSyncer implements ShardSyncer {
+
+    private static final Log LOG = LogFactory.getLog(KinesisShardSyncer.class);
+    private final LeaseCleanupValidator leaseCleanupValidator;
+
+    public KinesisShardSyncer(final LeaseCleanupValidator leaseCleanupValidator) {
+        this.leaseCleanupValidator = leaseCleanupValidator;
+    }
+
+    synchronized void bootstrapShardLeases(IKinesisProxy kinesisProxy, ILeaseManager<KinesisClientLease> leaseManager,
+                                           InitialPositionInStreamExtended initialPositionInStream,
+                                           boolean ignoreUnexpectedChildShards)
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException, KinesisClientLibIOException {
+        syncShardLeases(kinesisProxy, leaseManager, initialPositionInStream,
+                ignoreUnexpectedChildShards);
+    }
+
+    /**
+     * Check and create leases for any new shards (e.g. following a reshard operation).
+     *
+     * @param kinesisProxy
+     * @param leaseManager
+     * @param initialPositionInStream
+     * @param cleanupLeasesOfCompletedShards
+     * @param ignoreUnexpectedChildShards
+     * @throws DependencyException
+     * @throws InvalidStateException
+     * @throws ProvisionedThroughputException
+     * @throws KinesisClientLibIOException
+     */
+    @Override
+    public synchronized void checkAndCreateLeasesForNewShards(IKinesisProxy kinesisProxy, ILeaseManager<KinesisClientLease> leaseManager,
+                                          InitialPositionInStreamExtended initialPositionInStream, boolean cleanupLeasesOfCompletedShards,
+                                          boolean ignoreUnexpectedChildShards)
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException,
+            KinesisClientLibIOException {
+        syncShardLeases(kinesisProxy, leaseManager, initialPositionInStream, ignoreUnexpectedChildShards);
+    }
+
+    /**
+     * Check and create leases for any new shards (e.g. following a reshard operation).
+     *
+     * @param kinesisProxy
+     * @param leaseManager
+     * @param initialPositionInStream
+     * @param cleanupLeasesOfCompletedShards
+     * @param ignoreUnexpectedChildShards
+     * @param latestShards latest snapshot of shards to reuse
+     * @throws DependencyException
+     * @throws InvalidStateException
+     * @throws ProvisionedThroughputException
+     * @throws KinesisClientLibIOException
+     */
+    @Override
+    public synchronized void checkAndCreateLeasesForNewShards(IKinesisProxy kinesisProxy,
+            ILeaseManager<KinesisClientLease> leaseManager, InitialPositionInStreamExtended initialPositionInStream,
+            boolean cleanupLeasesOfCompletedShards, boolean ignoreUnexpectedChildShards, List<Shard> latestShards)
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException,
+            KinesisClientLibIOException {
+        syncShardLeases(kinesisProxy, leaseManager, initialPositionInStream,
+                ignoreUnexpectedChildShards, latestShards, leaseManager.isLeaseTableEmpty());
+    }
+
+    /**
+     * Sync leases with Kinesis shards (e.g. at startup, or when we reach end of a shard).
+     *
+     * @param kinesisProxy
+     * @param leaseManager
+     * @param initialPosition
+     * @param ignoreUnexpectedChildShards
+     * @throws DependencyException
+     * @throws InvalidStateException
+     * @throws ProvisionedThroughputException
+     * @throws KinesisClientLibIOException
+     */
+    private synchronized void syncShardLeases(IKinesisProxy kinesisProxy,
+                                              ILeaseManager<KinesisClientLease> leaseManager,
+                                              InitialPositionInStreamExtended initialPosition,
+                                              boolean ignoreUnexpectedChildShards)
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException, KinesisClientLibIOException {
+
+        // In the case where the lease table is empty, we want to synchronize the minimal amount of shards possible
+        // based on the given initial position.
+        // TODO: Implement shard list filtering on non-empty lease table case
+        final boolean isLeaseTableEmpty = leaseManager.isLeaseTableEmpty();
+        final List<Shard> latestShards = isLeaseTableEmpty
+                ? getShardListAtInitialPosition(kinesisProxy, initialPosition)
+                : getCompleteShardList(kinesisProxy);
+
+        syncShardLeases(kinesisProxy, leaseManager, initialPosition,
+                ignoreUnexpectedChildShards, latestShards, isLeaseTableEmpty);
+    }
+
+    /**
+     * Sync leases with Kinesis shards (e.g. at startup, or when we reach end of a shard).
+     *
+     * @param kinesisProxy
+     * @param leaseManager
+     * @param initialPosition
+     * @param ignoreUnexpectedChildShards
+     * @param latestShards latest snapshot of shards to reuse
+     * @throws DependencyException
+     * @throws InvalidStateException
+     * @throws ProvisionedThroughputException
+     * @throws KinesisClientLibIOException
+     */
+    // CHECKSTYLE:OFF CyclomaticComplexity
+    private synchronized void syncShardLeases(IKinesisProxy kinesisProxy,
+                                              ILeaseManager<KinesisClientLease> leaseManager,
+                                              InitialPositionInStreamExtended initialPosition,
+                                              boolean ignoreUnexpectedChildShards,
+                                              List<Shard> latestShards,
+                                              boolean isLeaseTableEmpty)
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException,
+            KinesisClientLibIOException {
+
+        List<Shard> shards;
+        if(CollectionUtils.isNullOrEmpty(latestShards)) {
+            shards = isLeaseTableEmpty ? getShardListAtInitialPosition(kinesisProxy, initialPosition) : getCompleteShardList(kinesisProxy);
+        } else {
+            shards = latestShards;
+        }
+        LOG.debug("Num Shards: " + shards.size());
+
+        Map<String, Shard> shardIdToShardMap = constructShardIdToShardMap(shards);
+        Map<String, Set<String>> shardIdToChildShardIdsMap = constructShardIdToChildShardIdsMap(shardIdToShardMap);
+        Set<String> inconsistentShardIds = findInconsistentShardIds(shardIdToChildShardIdsMap, shardIdToShardMap);
+        if (!ignoreUnexpectedChildShards) {
+            assertAllParentShardsAreClosed(inconsistentShardIds);
+        }
+
+        // Determine which lease sync strategy to use based on the state of the lease table
+        final LeaseSynchronizer leaseSynchronizer = isLeaseTableEmpty
+                ? new EmptyLeaseTableSynchronizer()
+                : new NonEmptyLeaseTableSynchronizer(shardIdToShardMap, shardIdToChildShardIdsMap);
+
+        final List<KinesisClientLease> currentLeases = leaseManager.listLeases();
+        final List<KinesisClientLease> newLeasesToCreate = determineNewLeasesToCreate(leaseSynchronizer, shards,
+                currentLeases, initialPosition, inconsistentShardIds);
+        LOG.debug("Num new leases to create: " + newLeasesToCreate.size());
+
+        for (KinesisClientLease lease : newLeasesToCreate) {
+            long startTimeMillis = System.currentTimeMillis();
+            boolean success = false;
+            try {
+                leaseManager.createLeaseIfNotExists(lease);
+                success = true;
+            } finally {
+                MetricsHelper.addSuccessAndLatency("CreateLease", startTimeMillis, success, MetricsLevel.DETAILED);
+            }
+        }
+
+        List<KinesisClientLease> trackedLeases = new ArrayList<>();
+        if (currentLeases != null) {
+            trackedLeases.addAll(currentLeases);
+        }
+        trackedLeases.addAll(newLeasesToCreate);
+    }
+    // CHECKSTYLE:ON CyclomaticComplexity
+
+    /** Helper method to detect a race condition between fetching the shards via paginated DescribeStream calls
+     * and a reshard operation.
+     * @param inconsistentShardIds
+     * @throws KinesisClientLibIOException
+     */
+    private void assertAllParentShardsAreClosed(Set<String> inconsistentShardIds) throws KinesisClientLibIOException {
+        if (!inconsistentShardIds.isEmpty()) {
+            String ids = StringUtils.join(inconsistentShardIds, ' ');
+            throw new KinesisClientLibIOException(String.format("%d open child shards (%s) are inconsistent. "
+                            + "This can happen due to a race condition between describeStream and a reshard operation.",
+                    inconsistentShardIds.size(), ids));
+        }
+    }
+
+    /**
+     * Helper method to construct the list of inconsistent shards, which are open shards with non-closed ancestor
+     * parent(s).
+     * @param shardIdToChildShardIdsMap
+     * @param shardIdToShardMap
+     * @return Set of inconsistent open shard ids for shards having open parents.
+     */
+    private Set<String> findInconsistentShardIds(Map<String, Set<String>> shardIdToChildShardIdsMap,
+            Map<String, Shard> shardIdToShardMap) {
+        Set<String> result = new HashSet<String>();
+        for (String parentShardId : shardIdToChildShardIdsMap.keySet()) {
+            Shard parentShard = shardIdToShardMap.get(parentShardId);
+            if ((parentShardId == null) || (parentShard.getSequenceNumberRange().getEndingSequenceNumber() == null)) {
+                Set<String> childShardIdsMap = shardIdToChildShardIdsMap.get(parentShardId);
+                result.addAll(childShardIdsMap);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Helper method to create a shardId->KinesisClientLease map.
+     * Note: This has package level access for testing purposes only.
+     * @param trackedLeaseList
+     * @return
+     */
+    Map<String, KinesisClientLease> constructShardIdToKCLLeaseMap(List<KinesisClientLease> trackedLeaseList) {
+        Map<String, KinesisClientLease> trackedLeasesMap = new HashMap<>();
+        for (KinesisClientLease lease : trackedLeaseList) {
+            trackedLeasesMap.put(lease.getLeaseKey(), lease);
+        }
+        return trackedLeasesMap;
+    }
+
+    /**
+     * Note: this has package level access for testing purposes.
+     * Useful for asserting that we don't have an incomplete shard list following a reshard operation.
+     * We verify that if the shard is present in the shard list, it is closed and its hash key range
+     * is covered by its child shards.
+     */
+    synchronized void assertClosedShardsAreCoveredOrAbsent(Map<String, Shard> shardIdToShardMap,
+            Map<String, Set<String>> shardIdToChildShardIdsMap, Set<String> shardIdsOfClosedShards)
+            throws KinesisClientLibIOException {
+        String exceptionMessageSuffix = "This can happen if we constructed the list of shards "
+                + " while a reshard operation was in progress.";
+
+        for (String shardId : shardIdsOfClosedShards) {
+            Shard shard = shardIdToShardMap.get(shardId);
+            if (shard == null) {
+                LOG.info("Shard " + shardId + " is not present in Kinesis anymore.");
+                continue;
+            }
+
+            String endingSequenceNumber = shard.getSequenceNumberRange().getEndingSequenceNumber();
+            if (endingSequenceNumber == null) {
+                throw new KinesisClientLibIOException("Shard " + shardIdsOfClosedShards + " is not closed. "
+                        + exceptionMessageSuffix);
+            }
+
+            Set<String> childShardIds = shardIdToChildShardIdsMap.get(shardId);
+            if (childShardIds == null) {
+                throw new KinesisClientLibIOException("Incomplete shard list: Closed shard " + shardId
+                        + " has no children." + exceptionMessageSuffix);
+            }
+
+            assertHashRangeOfClosedShardIsCovered(shard, shardIdToShardMap, childShardIds);
+        }
+    }
+
+    private synchronized void assertHashRangeOfClosedShardIsCovered(Shard closedShard,
+            Map<String, Shard> shardIdToShardMap, Set<String> childShardIds) throws KinesisClientLibIOException {
+
+        BigInteger startingHashKeyOfClosedShard = new BigInteger(closedShard.getHashKeyRange().getStartingHashKey());
+        BigInteger endingHashKeyOfClosedShard = new BigInteger(closedShard.getHashKeyRange().getEndingHashKey());
+        BigInteger minStartingHashKeyOfChildren = null;
+        BigInteger maxEndingHashKeyOfChildren = null;
+
+        for (String childShardId : childShardIds) {
+            Shard childShard = shardIdToShardMap.get(childShardId);
+            BigInteger startingHashKey = new BigInteger(childShard.getHashKeyRange().getStartingHashKey());
+            if ((minStartingHashKeyOfChildren == null) || (startingHashKey.compareTo(minStartingHashKeyOfChildren)
+                    < 0)) {
+                minStartingHashKeyOfChildren = startingHashKey;
+            }
+            BigInteger endingHashKey = new BigInteger(childShard.getHashKeyRange().getEndingHashKey());
+            if ((maxEndingHashKeyOfChildren == null) || (endingHashKey.compareTo(maxEndingHashKeyOfChildren) > 0)) {
+                maxEndingHashKeyOfChildren = endingHashKey;
+            }
+        }
+
+        if ((minStartingHashKeyOfChildren == null) || (maxEndingHashKeyOfChildren == null) || (
+                minStartingHashKeyOfChildren.compareTo(startingHashKeyOfClosedShard) > 0) || (
+                maxEndingHashKeyOfChildren.compareTo(endingHashKeyOfClosedShard) < 0)) {
+            throw new KinesisClientLibIOException("Incomplete shard list: hash key range of shard " + closedShard
+                    .getShardId() + " is not covered by its child shards.");
+        }
+
+    }
+
+    /**
+     * Helper method to construct shardId->setOfChildShardIds map.
+     * Note: This has package access for testing purposes only.
+     * @param shardIdToShardMap
+     * @return
+     */
+    static Map<String, Set<String>> constructShardIdToChildShardIdsMap(Map<String, Shard> shardIdToShardMap) {
+        Map<String, Set<String>> shardIdToChildShardIdsMap = new HashMap<>();
+        for (Map.Entry<String, Shard> entry : shardIdToShardMap.entrySet()) {
+            String shardId = entry.getKey();
+            Shard shard = entry.getValue();
+            String parentShardId = shard.getParentShardId();
+            if ((parentShardId != null) && (shardIdToShardMap.containsKey(parentShardId))) {
+                Set<String> childShardIds = shardIdToChildShardIdsMap.get(parentShardId);
+                if (childShardIds == null) {
+                    childShardIds = new HashSet<String>();
+                    shardIdToChildShardIdsMap.put(parentShardId, childShardIds);
+                }
+                childShardIds.add(shardId);
+            }
+
+            String adjacentParentShardId = shard.getAdjacentParentShardId();
+            if ((adjacentParentShardId != null) && (shardIdToShardMap.containsKey(adjacentParentShardId))) {
+                Set<String> childShardIds = shardIdToChildShardIdsMap.get(adjacentParentShardId);
+                if (childShardIds == null) {
+                    childShardIds = new HashSet<String>();
+                    shardIdToChildShardIdsMap.put(adjacentParentShardId, childShardIds);
+                }
+                childShardIds.add(shardId);
+            }
+        }
+        return shardIdToChildShardIdsMap;
+    }
+
+    private List<Shard> getCompleteShardList(IKinesisProxy kinesisProxy) throws KinesisClientLibIOException {
+        List<Shard> shards = kinesisProxy.getShardList();
+        if (shards == null) {
+            throw new KinesisClientLibIOException(
+                    "Stream is not in ACTIVE OR UPDATING state - will retry getting the shard list.");
+        }
+        return shards;
+    }
+
+    private List<Shard> getShardListAtInitialPosition(IKinesisProxy kinesisProxy,
+                                                      InitialPositionInStreamExtended initialPosition)
+            throws KinesisClientLibIOException {
+
+        final ShardFilter shardFilter = getShardFilterAtInitialPosition(initialPosition);
+        final List<Shard> shards = kinesisProxy.getShardListWithFilter(shardFilter);
+
+        if (shards == null) {
+            throw new KinesisClientLibIOException(
+                    "Stream is not in ACTIVE OR UPDATING state - will retry getting the shard list.");
+        }
+
+        return shards;
+    }
+
+    private static ShardFilter getShardFilterAtInitialPosition(InitialPositionInStreamExtended initialPosition) {
+        ShardFilter shardFilter = new ShardFilter();
+
+        switch (initialPosition.getInitialPositionInStream()) {
+            case LATEST:
+                shardFilter = shardFilter.withType(ShardFilterType.AT_LATEST);
+                break;
+            case TRIM_HORIZON:
+                shardFilter = shardFilter.withType(ShardFilterType.AT_TRIM_HORIZON);
+                break;
+            case AT_TIMESTAMP:
+                shardFilter = shardFilter.withType(ShardFilterType.AT_TIMESTAMP)
+                        .withTimestamp(initialPosition.getTimestamp());
+                break;
+            default:
+                throw new IllegalArgumentException(initialPosition.getInitialPositionInStream()
+                        + " is not a supported initial position in a Kinesis stream. Supported initial positions are"
+                        + " AT_LATEST, AT_TRIM_HORIZON, and AT_TIMESTAMP.");
+        }
+
+        return shardFilter;
+    }
+
+    /**
+     * Determine new leases to create and their initial checkpoint.
+     * Note: Package level access only for testing purposes.
+     *
+     * @param leaseSynchronizer determines the strategy to use when updating leases based on the current state of
+     *        the lease table (empty vs. non-empty)
+     * @param shards List of all shards in Kinesis (we'll create new leases based on this set)
+     * @param currentLeases List of current leases
+     * @param initialPosition One of LATEST, TRIM_HORIZON, or AT_TIMESTAMP. We'll start fetching records from that
+     *        location in the shard (when an application starts up for the first time - and there are no checkpoints).
+     * @param inconsistentShardIds Set of child shard ids having open parents.
+     * @return List of new leases to create sorted by starting sequenceNumber of the corresponding shard
+     */
+    List<KinesisClientLease> determineNewLeasesToCreate(LeaseSynchronizer leaseSynchronizer,
+                                                        List<Shard> shards,
+                                                        List<KinesisClientLease> currentLeases,
+                                                        InitialPositionInStreamExtended initialPosition,
+                                                        Set<String> inconsistentShardIds) {
+
+        return leaseSynchronizer.determineNewLeasesToCreate(shards, currentLeases, initialPosition,
+                inconsistentShardIds);
+    }
+
+    /**
+     * Determine new leases to create and their initial checkpoint.
+     * Note: Package level access only for testing purposes.
+     */
+    List<KinesisClientLease> determineNewLeasesToCreate(LeaseSynchronizer leaseSynchronizer,
+                                                        List<Shard> shards,
+                                                        List<KinesisClientLease> currentLeases,
+                                                        InitialPositionInStreamExtended initialPosition) {
+
+        Set<String> inconsistentShardIds = new HashSet<String>();
+        return determineNewLeasesToCreate(leaseSynchronizer, shards, currentLeases, initialPosition, inconsistentShardIds);
+    }
+
+    /**
+     * Note: Package level access for testing purposes only.
+     * Check if this shard is a descendant of a shard that is (or will be) processed.
+     * Create leases for the first ancestor of this shard that needs to be processed, as required.
+     * See javadoc of determineNewLeasesToCreate() for rules and example.
+     *
+     * @param shardId The shardId to check.
+     * @param initialPosition One of LATEST, TRIM_HORIZON, or AT_TIMESTAMP. We'll start fetching records from that
+     *        location in the shard (when an application starts up for the first time - and there are no checkpoints).
+     * @param shardIdsOfCurrentLeases The shardIds for the current leases.
+     * @param shardIdToShardMapOfAllKinesisShards ShardId->Shard map containing all shards obtained via DescribeStream.
+     * @param shardIdToLeaseMapOfNewShards Add lease POJOs corresponding to ancestors to this map.
+     * @param memoizationContext Memoization of shards that have been evaluated as part of the evaluation
+     * @return true if the shard is a descendant of any current shard (lease already exists)
+     */
+    // CHECKSTYLE:OFF CyclomaticComplexity
+    static boolean checkIfDescendantAndAddNewLeasesForAncestors(String shardId,
+            InitialPositionInStreamExtended initialPosition, Set<String> shardIdsOfCurrentLeases,
+            Map<String, Shard> shardIdToShardMapOfAllKinesisShards,
+            Map<String, KinesisClientLease> shardIdToLeaseMapOfNewShards, MemoizationContext memoizationContext) {
+
+        final Boolean previousValue = memoizationContext.isDescendant(shardId);
+
+        if (previousValue != null) {
+            return previousValue;
+        }
+
+        boolean isDescendant = false;
+        Shard shard;
+        Set<String> parentShardIds;
+        Set<String> descendantParentShardIds = new HashSet<String>();
+
+        if ((shardId != null) && (shardIdToShardMapOfAllKinesisShards.containsKey(shardId))) {
+            if (shardIdsOfCurrentLeases.contains(shardId)) {
+                // This shard is a descendant of a current shard.
+                isDescendant = true;
+                // We don't need to add leases of its ancestors,
+                // because we'd have done it when creating a lease for this shard.
+            } else {
+                shard = shardIdToShardMapOfAllKinesisShards.get(shardId);
+                parentShardIds = getParentShardIds(shard, shardIdToShardMapOfAllKinesisShards);
+                for (String parentShardId : parentShardIds) {
+                    // Check if the parent is a descendant, and include its ancestors. Or, if the parent is NOT a
+                    // descendant but we should create a lease for it anyway (e.g. to include in processing from
+                    // TRIM_HORIZON or AT_TIMESTAMP). If either is true, then we mark the current shard as a descendant.
+                    final boolean isParentDescendant = checkIfDescendantAndAddNewLeasesForAncestors(parentShardId,
+                            initialPosition, shardIdsOfCurrentLeases, shardIdToShardMapOfAllKinesisShards,
+                            shardIdToLeaseMapOfNewShards, memoizationContext);
+                    if (isParentDescendant || memoizationContext.shouldCreateLease(parentShardId)) {
+                        isDescendant = true;
+                        descendantParentShardIds.add(parentShardId);
+                        LOG.debug("Parent shard " + parentShardId + " is a descendant.");
+                    } else {
+                        LOG.debug("Parent shard " + parentShardId + " is NOT a descendant.");
+                    }
+                }
+
+                // If this is a descendant, create leases for its parent shards (if they don't exist)
+                if (isDescendant) {
+                    for (String parentShardId : parentShardIds) {
+                        if (!shardIdsOfCurrentLeases.contains(parentShardId)) {
+                            KinesisClientLease lease = shardIdToLeaseMapOfNewShards.get(parentShardId);
+
+                            // If the lease for the parent shard does not already exist, there are two cases in which we
+                            // would want to create it:
+                            // - If we have already marked the parentShardId for lease creation in a prior recursive
+                            //   call. This could happen if we are trying to process from TRIM_HORIZON or AT_TIMESTAMP.
+                            // - If the parent shard is not a descendant but the current shard is a descendant, then
+                            //   the parent shard is the oldest shard in the shard hierarchy that does not have an
+                            //   ancestor in the lease table (the adjacent parent is necessarily a descendant, and
+                            //   therefore covered in the lease table). So we should create a lease for the parent.
+
+                            if (lease == null) {
+                                if (memoizationContext.shouldCreateLease(parentShardId) ||
+                                        !descendantParentShardIds.contains(parentShardId)) {
+                                    LOG.debug("Need to create a lease for shardId " + parentShardId);
+                                    lease = newKCLLease(shardIdToShardMapOfAllKinesisShards.get(parentShardId));
+                                    shardIdToLeaseMapOfNewShards.put(parentShardId, lease);
+                                }
+                            }
+
+                            /**
+                             * If the shard is a descendant and the specified initial position is AT_TIMESTAMP, then the
+                             * checkpoint should be set to AT_TIMESTAMP, else to TRIM_HORIZON. For AT_TIMESTAMP, we will
+                             * add a lease just like we do for TRIM_HORIZON. However we will only return back records
+                             * with server-side timestamp at or after the specified initial position timestamp.
+                             *
+                             * Shard structure (each level depicts a stream segment):
+                             * 0 1 2 3 4   5   - shards till epoch 102
+                             * \ / \ / |   |
+                             *  6   7  4   5   - shards from epoch 103 - 205
+                             *   \ /   |  /\
+                             *    8    4 9  10 - shards from epoch 206 (open - no ending sequenceNumber)
+                             *
+                             * Current leases: (4, 5, 7)
+                             *
+                             * For the above example, suppose the initial position in stream is set to AT_TIMESTAMP with
+                             * timestamp value 206. We will then create new leases for all the shards 0 and 1 (with
+                             * checkpoint set AT_TIMESTAMP), even though these ancestor shards have an epoch less than
+                             * 206. However as we begin processing the ancestor shards, their checkpoints would be
+                             * updated to SHARD_END and their leases would then be deleted since they won't have records
+                             * with server-side timestamp at/after 206. And after that we will begin processing the
+                             * descendant shards with epoch at/after 206 and we will return the records that meet the
+                             * timestamp requirement for these shards.
+                             */
+                            if (lease != null) {
+                                if (descendantParentShardIds.contains(parentShardId) && !initialPosition
+                                        .getInitialPositionInStream().equals(InitialPositionInStream.AT_TIMESTAMP)) {
+                                    lease.setCheckpoint(ExtendedSequenceNumber.TRIM_HORIZON);
+                                } else {
+                                    lease.setCheckpoint(convertToCheckpoint(initialPosition));
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    // This shard is not a descendant, but should still be included if the customer wants to process all
+                    // records in the stream or if the initial position is AT_TIMESTAMP. For AT_TIMESTAMP, we will add a
+                    // lease just like we do for TRIM_HORIZON. However we will only return back records with server-side
+                    // timestamp at or after the specified initial position timestamp.
+                    if (initialPosition.getInitialPositionInStream().equals(InitialPositionInStream.TRIM_HORIZON)
+                            || initialPosition.getInitialPositionInStream()
+                            .equals(InitialPositionInStream.AT_TIMESTAMP)) {
+                        memoizationContext.setShouldCreateLease(shardId, true);
+                    }
+                }
+
+            }
+        }
+
+        memoizationContext.setIsDescendant(shardId, isDescendant);
+        return isDescendant;
+    }
+    // CHECKSTYLE:ON CyclomaticComplexity
+
+    /**
+     * Helper method to get parent shardIds of the current shard - includes the parent shardIds if:
+     * a/ they are not null
+     * b/ if they exist in the current shard map (i.e. haven't expired)
+     *
+     * @param shard Will return parents of this shard
+     * @param shardIdToShardMapOfAllKinesisShards ShardId->Shard map containing all shards obtained via DescribeStream.
+     * @return Set of parentShardIds
+     */
+    static Set<String> getParentShardIds(Shard shard, Map<String, Shard> shardIdToShardMapOfAllKinesisShards) {
+        Set<String> parentShardIds = new HashSet<String>(2);
+        String parentShardId = shard.getParentShardId();
+        if ((parentShardId != null) && shardIdToShardMapOfAllKinesisShards.containsKey(parentShardId)) {
+            parentShardIds.add(parentShardId);
+        }
+        String adjacentParentShardId = shard.getAdjacentParentShardId();
+        if ((adjacentParentShardId != null) && shardIdToShardMapOfAllKinesisShards.containsKey(adjacentParentShardId)) {
+            parentShardIds.add(adjacentParentShardId);
+        }
+        return parentShardIds;
+    }
+
+    /**
+     * Helper method to create a new KinesisClientLease POJO for a shard.
+     * Note: Package level access only for testing purposes
+     *
+     * @param shard
+     * @return
+     */
+    static KinesisClientLease newKCLLease(Shard shard) {
+        KinesisClientLease newLease = new KinesisClientLease();
+        newLease.setLeaseKey(shard.getShardId());
+        List<String> parentShardIds = new ArrayList<String>(2);
+        if (shard.getParentShardId() != null) {
+            parentShardIds.add(shard.getParentShardId());
+        }
+        if (shard.getAdjacentParentShardId() != null) {
+            parentShardIds.add(shard.getAdjacentParentShardId());
+        }
+        newLease.setParentShardIds(parentShardIds);
+        newLease.setOwnerSwitchesSinceCheckpoint(0L);
+        newLease.setHashKeyRange(fromHashKeyRange(shard.getHashKeyRange()));
+        return newLease;
+    }
+
+    /**
+     * Helper method to create a new KinesisClientLease POJO for a ChildShard.
+     * Note: Package level access only for testing purposes
+     *
+     * @param childShard
+     * @return
+     */
+    static KinesisClientLease newKCLLeaseForChildShard(ChildShard childShard) throws InvalidStateException {
+        final KinesisClientLease newLease = new KinesisClientLease();
+        newLease.setLeaseKey(childShard.getShardId());
+        final List<String> parentShardIds = new ArrayList<>();
+        if (!CollectionUtils.isNullOrEmpty(childShard.getParentShards())) {
+            parentShardIds.addAll(childShard.getParentShards());
+        } else {
+            throw new InvalidStateException("Unable to populate new lease for child shard " + childShard.getShardId()
+            + " because parent shards cannot be found.");
+        }
+        newLease.setParentShardIds(parentShardIds);
+        newLease.setOwnerSwitchesSinceCheckpoint(0L);
+        newLease.setCheckpoint(ExtendedSequenceNumber.TRIM_HORIZON);
+        newLease.setHashKeyRange(fromHashKeyRange(childShard.getHashKeyRange()));
+        return newLease;
+    }
+
+    /**
+     * Helper method to construct a shardId->Shard map for the specified list of shards.
+     *
+     * @param shards List of shards
+     * @return ShardId->Shard map
+     */
+    static Map<String, Shard> constructShardIdToShardMap(List<Shard> shards) {
+        Map<String, Shard> shardIdToShardMap = new HashMap<String, Shard>();
+        for (Shard shard : shards) {
+            shardIdToShardMap.put(shard.getShardId(), shard);
+        }
+        return shardIdToShardMap;
+    }
+
+    /**
+     * Helper method to return all the open shards for a stream.
+     * Note: Package level access only for testing purposes.
+     *
+     * @param allShards All shards returved via DescribeStream. We assume this to represent a consistent shard list.
+     * @return List of open shards (shards at the tip of the stream) - may include shards that are not yet active.
+     */
+    static List<Shard> getOpenShards(List<Shard> allShards) {
+        List<Shard> openShards = new ArrayList<Shard>();
+        for (Shard shard : allShards) {
+            String endingSequenceNumber = shard.getSequenceNumberRange().getEndingSequenceNumber();
+            if (endingSequenceNumber == null) {
+                openShards.add(shard);
+                LOG.debug("Found open shard: " + shard.getShardId());
+            }
+        }
+        return openShards;
+    }
+
+    static ExtendedSequenceNumber convertToCheckpoint(InitialPositionInStreamExtended position) {
+        ExtendedSequenceNumber checkpoint = null;
+
+        if (position.getInitialPositionInStream().equals(InitialPositionInStream.TRIM_HORIZON)) {
+            checkpoint = ExtendedSequenceNumber.TRIM_HORIZON;
+        } else if (position.getInitialPositionInStream().equals(InitialPositionInStream.LATEST)) {
+            checkpoint = ExtendedSequenceNumber.LATEST;
+        } else if (position.getInitialPositionInStream().equals(InitialPositionInStream.AT_TIMESTAMP)) {
+            checkpoint = ExtendedSequenceNumber.AT_TIMESTAMP;
+        }
+
+        return checkpoint;
+    }
+
+    /** Helper class to compare leases based on starting sequence number of the corresponding shards.
+     *
+     */
+    static class StartingSequenceNumberAndShardIdBasedComparator implements Comparator<KinesisClientLease>,
+            Serializable {
+
+        private static final long serialVersionUID = 1L;
+
+        private final Map<String, Shard> shardIdToShardMap;
+
+        /**
+         * @param shardIdToShardMapOfAllKinesisShards
+         */
+        public StartingSequenceNumberAndShardIdBasedComparator(Map<String, Shard> shardIdToShardMapOfAllKinesisShards) {
+            shardIdToShardMap = shardIdToShardMapOfAllKinesisShards;
+        }
+
+        /**
+         * Compares two leases based on the starting sequence number of corresponding shards.
+         * If shards are not found in the shardId->shard map supplied, we do a string comparison on the shardIds.
+         * We assume that lease1 and lease2 are:
+         *     a/ not null,
+         *     b/ shards (if found) have non-null starting sequence numbers
+         *
+         * {@inheritDoc}
+         */
+        @Override
+        public int compare(KinesisClientLease lease1, KinesisClientLease lease2) {
+            int result = 0;
+            String shardId1 = lease1.getLeaseKey();
+            String shardId2 = lease2.getLeaseKey();
+            Shard shard1 = shardIdToShardMap.get(shardId1);
+            Shard shard2 = shardIdToShardMap.get(shardId2);
+
+            // If we found shards for the two leases, use comparison of the starting sequence numbers
+            if ((shard1 != null) && (shard2 != null)) {
+                BigInteger sequenceNumber1 = new BigInteger(
+                        shard1.getSequenceNumberRange().getStartingSequenceNumber());
+                BigInteger sequenceNumber2 = new BigInteger(
+                        shard2.getSequenceNumberRange().getStartingSequenceNumber());
+                result = sequenceNumber1.compareTo(sequenceNumber2);
+            }
+
+            if (result == 0) {
+                result = shardId1.compareTo(shardId2);
+            }
+
+            return result;
+        }
+
+    }
+
+    /**
+     * Helper class to pass around state between recursive traversals of shard hierarchy.
+     */
+    @NoArgsConstructor
+    static class MemoizationContext {
+        private Map<String, Boolean> isDescendantMap = new HashMap<>();
+        private Map<String, Boolean> shouldCreateLeaseMap = new HashMap<>();
+
+        Boolean isDescendant(String shardId) {
+            return isDescendantMap.get(shardId);
+        }
+
+        void setIsDescendant(String shardId, Boolean isDescendant) {
+            isDescendantMap.put(shardId, isDescendant);
+        }
+
+        Boolean shouldCreateLease(String shardId) {
+            return shouldCreateLeaseMap.computeIfAbsent(shardId, x -> Boolean.FALSE);
+        }
+
+        void setShouldCreateLease(String shardId, Boolean shouldCreateLease) {
+            shouldCreateLeaseMap.put(shardId, shouldCreateLease);
+        }
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShutdownTask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/KinesisShutdownTask.java
@ -0,0 +1,337 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.exceptions.internal.BlockedOnParentShardException;
+import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessor;
+import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
+import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;
+import com.amazonaws.services.kinesis.clientlibrary.types.ShutdownInput;
+import com.amazonaws.services.kinesis.leases.LeasePendingDeletion;
+import com.amazonaws.services.kinesis.leases.exceptions.CustomerApplicationException;
+import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
+import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
+import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager;
+import com.amazonaws.services.kinesis.leases.impl.UpdateField;
+import com.amazonaws.services.kinesis.model.ChildShard;
+import com.amazonaws.util.CollectionUtils;
+import com.google.common.annotations.VisibleForTesting;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Random;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Task for invoking the RecordProcessor shutdown() callback.
+ */
+public class KinesisShutdownTask implements ITask {
+
+    private static final Log LOG = LogFactory.getLog(KinesisShutdownTask.class);
+
+    @VisibleForTesting
+    static final int RETRY_RANDOM_MAX_RANGE = 50;
+
+    private final ShardInfo shardInfo;
+    private final IRecordProcessor recordProcessor;
+    private final RecordProcessorCheckpointer recordProcessorCheckpointer;
+    private final ShutdownReason reason;
+    private final IKinesisProxy kinesisProxy;
+    private final KinesisClientLibLeaseCoordinator leaseCoordinator;
+    private final InitialPositionInStreamExtended initialPositionInStream;
+    private final boolean cleanupLeasesOfCompletedShards;
+    private final boolean ignoreUnexpectedChildShards;
+    private final TaskType taskType = TaskType.SHUTDOWN;
+    private final long backoffTimeMillis;
+    private final GetRecordsCache getRecordsCache;
+    private final ShardSyncer shardSyncer;
+    private final ShardSyncStrategy shardSyncStrategy;
+    private final List<ChildShard> childShards;
+    private final LeaseCleanupManager leaseCleanupManager;
+
+    /**
+     * Constructor.
+     */
+    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 10 LINES
+    KinesisShutdownTask(ShardInfo shardInfo,
+            IRecordProcessor recordProcessor,
+            RecordProcessorCheckpointer recordProcessorCheckpointer,
+            ShutdownReason reason,
+            IKinesisProxy kinesisProxy,
+            InitialPositionInStreamExtended initialPositionInStream,
+            boolean cleanupLeasesOfCompletedShards,
+            boolean ignoreUnexpectedChildShards,
+            KinesisClientLibLeaseCoordinator leaseCoordinator,
+            long backoffTimeMillis,
+            GetRecordsCache getRecordsCache, ShardSyncer shardSyncer,
+            ShardSyncStrategy shardSyncStrategy, List<ChildShard> childShards,
+            LeaseCleanupManager leaseCleanupManager) {
+        this.shardInfo = shardInfo;
+        this.recordProcessor = recordProcessor;
+        this.recordProcessorCheckpointer = recordProcessorCheckpointer;
+        this.reason = reason;
+        this.kinesisProxy = kinesisProxy;
+        this.initialPositionInStream = initialPositionInStream;
+        this.cleanupLeasesOfCompletedShards = cleanupLeasesOfCompletedShards;
+        this.ignoreUnexpectedChildShards = ignoreUnexpectedChildShards;
+        this.leaseCoordinator = leaseCoordinator;
+        this.backoffTimeMillis = backoffTimeMillis;
+        this.getRecordsCache = getRecordsCache;
+        this.shardSyncer = shardSyncer;
+        this.shardSyncStrategy = shardSyncStrategy;
+        this.childShards = childShards;
+        this.leaseCleanupManager = leaseCleanupManager;
+    }
+
+    /*
+     * Invokes RecordProcessor shutdown() API.
+     * (non-Javadoc)
+     *
+     * @see com.amazonaws.services.kinesis.clientlibrary.lib.worker.ITask#call()
+     */
+    @Override
+    public TaskResult call() {
+        Exception exception;
+
+        LOG.info("Invoking shutdown() for shard " + shardInfo.getShardId() + ", concurrencyToken: "
+                         + shardInfo.getConcurrencyToken() + ", original Shutdown reason: " + reason + ". childShards:" + childShards);
+
+        try {
+            final KinesisClientLease currentShardLease = leaseCoordinator.getCurrentlyHeldLease(shardInfo.getShardId());
+            final Runnable leaseLostAction = () -> takeLeaseLostAction();
+
+            if (reason == ShutdownReason.TERMINATE) {
+                try {
+                    takeShardEndAction(currentShardLease);
+                } catch (InvalidStateException e) {
+                    // If InvalidStateException happens, it indicates we have a non recoverable error in short term.
+                    // In this scenario, we should shutdown the shardConsumer with ZOMBIE reason to allow other worker to take the lease and retry shutting down.
+                    LOG.warn("Lease " + shardInfo.getShardId() + ": Invalid state encountered while shutting down shardConsumer with TERMINATE reason. " +
+                                     "Dropping the lease and shutting down shardConsumer using ZOMBIE reason. ", e);
+                    dropLease(currentShardLease);
+                    throwOnApplicationException(leaseLostAction);
+                }
+            } else {
+                throwOnApplicationException(leaseLostAction);
+            }
+
+            LOG.debug("Shutting down retrieval strategy.");
+            getRecordsCache.shutdown();
+            LOG.debug("Record processor completed shutdown() for shard " + shardInfo.getShardId());
+            return new TaskResult(null);
+        } catch (Exception e) {
+            if (e instanceof CustomerApplicationException) {
+                LOG.error("Shard " + shardInfo.getShardId() + ": Application exception: ", e);
+            } else {
+                LOG.error("Shard " + shardInfo.getShardId() + ": Caught exception: ", e);
+            }
+
+            exception = e;
+            // backoff if we encounter an exception.
+            try {
+                Thread.sleep(this.backoffTimeMillis);
+            } catch (InterruptedException ie) {
+                LOG.debug("Interrupted sleep", ie);
+            }
+        }
+
+        return new TaskResult(exception);
+    }
+
+    // Involves persisting child shard info, attempt to checkpoint and enqueueing lease for cleanup.
+    private void takeShardEndAction(KinesisClientLease currentShardLease)
+        throws InvalidStateException, DependencyException, ProvisionedThroughputException, CustomerApplicationException {
+        // Create new lease for the child shards if they don't exist.
+        // We have one valid scenario that shutdown task got created with SHARD_END reason and an empty list of childShards.
+        // This would happen when KinesisDataFetcher catches ResourceNotFound exception.
+        // In this case, KinesisDataFetcher will send out SHARD_END signal to trigger a shutdown task with empty list of childShards.
+        // This scenario could happen when customer deletes the stream while leaving the KCL application running.
+        if (currentShardLease == null) {
+            throw new InvalidStateException("Shard " + shardInfo.getShardId() + ": Lease not owned by the current worker. Leaving ShardEnd handling to new owner.");
+        }
+        if (!CollectionUtils.isNullOrEmpty(childShards)) {
+            // If childShards is not empty, create new leases for the childShards and update the current lease with the childShards lease information.
+            createLeasesForChildShardsIfNotExist();
+            updateCurrentLeaseWithChildShards(currentShardLease);
+        } else {
+            LOG.warn("Shard " + shardInfo.getShardId()
+                             + ": Shutting down consumer with SHARD_END reason without creating leases for child shards.");
+        }
+        // Checkpoint with SHARD_END sequence number.
+        final LeasePendingDeletion leasePendingDeletion = new LeasePendingDeletion(currentShardLease, shardInfo);
+        if (!leaseCleanupManager.isEnqueuedForDeletion(leasePendingDeletion)) {
+            boolean isSuccess = false;
+            try {
+                isSuccess = attemptShardEndCheckpointing();
+            } finally {
+                // Check if either the shard end ddb persist is successful or
+                // if childshards is empty. When child shards is empty then either it is due to
+                // completed shard being reprocessed or we got RNF from service.
+                // For these cases enqueue the lease for deletion.
+                if (isSuccess || CollectionUtils.isNullOrEmpty(childShards)) {
+                    leaseCleanupManager.enqueueForDeletion(leasePendingDeletion);
+                }
+            }
+        }
+    }
+
+    private void takeLeaseLostAction() {
+        final ShutdownInput leaseLostShutdownInput = new ShutdownInput()
+                .withShutdownReason(ShutdownReason.ZOMBIE)
+                .withCheckpointer(recordProcessorCheckpointer);
+        recordProcessor.shutdown(leaseLostShutdownInput);
+    }
+
+    private boolean attemptShardEndCheckpointing()
+        throws DependencyException, ProvisionedThroughputException, InvalidStateException, CustomerApplicationException {
+        final KinesisClientLease leaseFromDdb = Optional.ofNullable(leaseCoordinator.getLeaseManager().getLease(shardInfo.getShardId()))
+                .orElseThrow(() -> new InvalidStateException("Lease for shard " + shardInfo.getShardId() + " does not exist."));
+        if (!leaseFromDdb.getCheckpoint().equals(ExtendedSequenceNumber.SHARD_END)) {
+            // Call the recordProcessor to checkpoint with SHARD_END sequence number.
+            // The recordProcessor.shutdown is implemented by customer. We should validate if the SHARD_END checkpointing is successful after calling recordProcessor.shutdown.
+            throwOnApplicationException(() -> applicationCheckpointAndVerification());
+        }
+        return true;
+    }
+
+    private void applicationCheckpointAndVerification() {
+        recordProcessorCheckpointer.setSequenceNumberAtShardEnd(
+                recordProcessorCheckpointer.getLargestPermittedCheckpointValue());
+        recordProcessorCheckpointer.setLargestPermittedCheckpointValue(ExtendedSequenceNumber.SHARD_END);
+        final ShutdownInput shardEndShutdownInput = new ShutdownInput()
+                .withShutdownReason(ShutdownReason.TERMINATE)
+                .withCheckpointer(recordProcessorCheckpointer);
+        recordProcessor.shutdown(shardEndShutdownInput);
+
+        boolean successfullyCheckpointedShardEnd = false;
+
+        KinesisClientLease leaseFromDdb = null;
+        try {
+            leaseFromDdb = leaseCoordinator.getLeaseManager().getLease(shardInfo.getShardId());
+        } catch (Exception e) {
+            LOG.error("Shard " + shardInfo.getShardId() + " : Unable to get lease entry for shard to verify shard end checkpointing.", e);
+        }
+
+        if (leaseFromDdb != null && leaseFromDdb.getCheckpoint() != null) {
+            successfullyCheckpointedShardEnd = leaseFromDdb.getCheckpoint().equals(ExtendedSequenceNumber.SHARD_END);
+            final ExtendedSequenceNumber lastCheckpointValue = recordProcessorCheckpointer.getLastCheckpointValue();
+            if (!leaseFromDdb.getCheckpoint().equals(lastCheckpointValue)) {
+                LOG.error("Shard " + shardInfo.getShardId() +
+                        " : Checkpoint information mismatch between authoritative source and local cache. " +
+                        "This does not affect the application flow, but cut a ticket to Kinesis when you see this. " +
+                        "Authoritative entry : " + leaseFromDdb.getCheckpoint() + " Cache entry : " + lastCheckpointValue);
+            }
+        } else {
+            LOG.error("Shard " + shardInfo.getShardId() + " : No lease checkpoint entry for shard to verify shard end checkpointing. Lease Entry : " + leaseFromDdb);
+        }
+
+        if (!successfullyCheckpointedShardEnd) {
+            throw new IllegalArgumentException("Application didn't checkpoint at end of shard "
+                                                       + shardInfo.getShardId() + ". Application must checkpoint upon shutdown. " +
+                                                       "See IRecordProcessor.shutdown javadocs for more information.");
+        }
+    }
+
+    private void throwOnApplicationException(Runnable action) throws CustomerApplicationException {
+        try {
+            action.run();
+        } catch (Exception e) {
+            throw new CustomerApplicationException("Customer application throws exception for shard " + shardInfo.getShardId(), e);
+        }
+    }
+
+    private void createLeasesForChildShardsIfNotExist() throws InvalidStateException, DependencyException, ProvisionedThroughputException {
+        // For child shard resulted from merge of two parent shards, verify if both the parents are either present or
+        // not present in the lease table before creating the lease entry.
+        if (!CollectionUtils.isNullOrEmpty(childShards) && childShards.size() == 1) {
+            final ChildShard childShard = childShards.get(0);
+            final List<String> parentLeaseKeys = childShard.getParentShards();
+
+            if (parentLeaseKeys.size() != 2) {
+                throw new InvalidStateException("Shard " + shardInfo.getShardId()+ "'s only child shard " + childShard
+                                                        + " does not contain other parent information.");
+            } else {
+                boolean isValidLeaseTableState = Objects.isNull(leaseCoordinator.getLeaseManager().getLease(parentLeaseKeys.get(0))) ==
+                                                 Objects.isNull(leaseCoordinator.getLeaseManager().getLease(parentLeaseKeys.get(1)));
+                if (!isValidLeaseTableState) {
+                    if(!isOneInNProbability(RETRY_RANDOM_MAX_RANGE)) {
+                        throw new BlockedOnParentShardException(
+                                "Shard " + shardInfo.getShardId() + "'s only child shard " + childShard
+                                        + " has partial parent information in lease table. Hence deferring lease creation of child shard.");
+                    } else {
+                        throw new InvalidStateException("Shard " + shardInfo.getShardId() + "'s only child shard " + childShard
+                                                                + " has partial parent information in lease table.");
+                    }
+                }
+            }
+        }
+        // Attempt create leases for child shards.
+        for (ChildShard childShard : childShards) {
+            final String leaseKey = childShard.getShardId();
+            if (leaseCoordinator.getLeaseManager().getLease(leaseKey) == null) {
+                final KinesisClientLease leaseToCreate = KinesisShardSyncer.newKCLLeaseForChildShard(childShard);
+                leaseCoordinator.getLeaseManager().createLeaseIfNotExists(leaseToCreate);
+                LOG.info("Shard " + shardInfo.getShardId() + " : Created child shard lease: " + leaseToCreate.getLeaseKey());
+            }
+        }
+    }
+
+    /**
+     * Returns true for 1 in N probability.
+     */
+    @VisibleForTesting
+    boolean isOneInNProbability(int n) {
+        Random r = new Random();
+        return 1 == r.nextInt((n - 1) + 1) + 1;
+    }
+
+    private void updateCurrentLeaseWithChildShards(KinesisClientLease currentLease) throws DependencyException, InvalidStateException, ProvisionedThroughputException {
+        final Set<String> childShardIds = childShards.stream().map(ChildShard::getShardId).collect(Collectors.toSet());
+        currentLease.setChildShardIds(childShardIds);
+        leaseCoordinator.getLeaseManager().updateLeaseWithMetaInfo(currentLease, UpdateField.CHILD_SHARDS);
+        LOG.info("Shard " + shardInfo.getShardId() + ": Updated current lease with child shard information: " + currentLease.getLeaseKey());
+    }
+
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.amazonaws.services.kinesis.clientlibrary.lib.worker.ITask#getTaskType()
+     */
+    @Override
+    public TaskType getTaskType() {
+        return taskType;
+    }
+
+    @VisibleForTesting
+    ShutdownReason getReason() {
+        return reason;
+    }
+
+    private void dropLease(KinesisClientLease currentShardLease) {
+        if (currentShardLease == null) {
+            LOG.warn("Shard " + shardInfo.getShardId() + ": Unable to find the lease for shard. Will shutdown the shardConsumer directly.");
+            return;
+        }
+        leaseCoordinator.dropLease(currentShardLease);
+        LOG.warn("Dropped lease for shutting down ShardConsumer: " + currentShardLease.getLeaseKey());
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/LeaderDecider.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/LeaderDecider.java
@ -0,0 +1,39 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+/**
+ * Used in conjunction with periodic shard sync.
+ * Implement this interface to allow KCL to decide if the current worker should execute shard sync.
+ * When periodic shard sync is enabled, PeriodicShardSyncManager periodically checks if the current
+ * worker is one of the leaders designated to execute shard-sync and then acts accordingly.
+ */
+public interface LeaderDecider {
+
+    /**
+     * Method invoked to check the given workerId corresponds to one of the workers
+     * designated to execute shard-syncs periodically.
+     *
+     * @param workerId ID of the worker
+     * @return True if the worker with ID workerId can execute shard-sync. False otherwise.
+     */
+    Boolean isLeader(String workerId);
+
+    /**
+     * Can be invoked, if needed, to shutdown any clients/thread-pools
+     * being used in the LeaderDecider implementation.
+     */
+    void shutdown();
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/LeaseCleanupValidator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/LeaseCleanupValidator.java
@ -0,0 +1,22 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.exceptions.internal.KinesisClientLibIOException;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+
+import java.util.Set;
+
+/**
+ * Represents the class that decides if a lease is eligible for cleanup.
+ */
+@Deprecated
+public interface LeaseCleanupValidator {
+
+    /**
+     * @param lease Candidate shard we are considering for deletion.
+     * @param currentKinesisShardIds
+     * @return boolean representing if the lease is eligible for cleanup.
+     * @throws KinesisClientLibIOException
+     */
+    boolean isCandidateForCleanup(KinesisClientLease lease, Set<String> currentKinesisShardIds)
+            throws KinesisClientLibIOException;
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/LeaseSynchronizer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/LeaseSynchronizer.java
@ -0,0 +1,41 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.model.Shard;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Interface used by {@link KinesisShardSyncer} to determine how to create new leases based on the current state
+ * of the lease table (i.e. whether the lease table is empty or non-empty).
+ */
+interface LeaseSynchronizer {
+
+    /**
+     * Determines how to create leases.
+     * @param shards
+     * @param currentLeases
+     * @param initialPosition
+     * @param inconsistentShardIds
+     * @return
+     */
+    List<KinesisClientLease> determineNewLeasesToCreate(List<Shard> shards,
+                                                        List<KinesisClientLease> currentLeases,
+                                                        InitialPositionInStreamExtended initialPosition,
+                                                        Set<String> inconsistentShardIds);
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/MetricsCollectingTaskDecorator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/MetricsCollectingTaskDecorator.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -21,7 +21,7 @@ import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
 /**
 * Decorates an ITask and reports metrics about its timing and success/failure.
 */
-class MetricsCollectingTaskDecorator implements ITask {
+public class MetricsCollectingTaskDecorator implements ITask {

    private final ITask other;
    private final IMetricsFactory factory;
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/NoOpShardPrioritization.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/NoOpShardPrioritization.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/NonEmptyLeaseTableSynchronizer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/NonEmptyLeaseTableSynchronizer.java
@ -0,0 +1,162 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.impl.Lease;
+import com.amazonaws.services.kinesis.model.Shard;
+import lombok.AllArgsConstructor;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * TODO - non-empty lease table sync story
+ */
+@AllArgsConstructor
+class NonEmptyLeaseTableSynchronizer implements LeaseSynchronizer {
+
+    private static final Log LOG = LogFactory.getLog(NonEmptyLeaseTableSynchronizer.class);
+
+    private final Map<String, Shard> shardIdToShardMap;
+    private final Map<String, Set<String>> shardIdToChildShardIdsMap;
+
+    /**
+     * Determine new leases to create and their initial checkpoint.
+     * Note: Package level access only for testing purposes.
+     *
+     * For each open (no ending sequence number) shard without open parents that doesn't already have a lease,
+     * determine if it is a descendant of any shard which is or will be processed (e.g. for which a lease exists):
+     * If so, create a lease for the first ancestor that needs to be processed (if needed). We will create leases
+     * for no more than one level in the ancestry tree. Once we find the first ancestor that needs to be processed,
+     * we will avoid creating leases for further descendants of that ancestor.
+     * If not, set checkpoint of the shard to the initial position specified by the client.
+     * To check if we need to create leases for ancestors, we use the following rules:
+     *   * If we began (or will begin) processing data for a shard, then we must reach end of that shard before
+     *         we begin processing data from any of its descendants.
+     *   * A shard does not start processing data until data from all its parents has been processed.
+     * Note, if the initial position is LATEST and a shard has two parents and only one is a descendant - we'll create
+     * leases corresponding to both the parents - the parent shard which is not a descendant will have
+     * its checkpoint set to Latest.
+     *
+     * We assume that if there is an existing lease for a shard, then either:
+     *   * we have previously created a lease for its parent (if it was needed), or
+     *   * the parent shard has expired.
+     *
+     * For example:
+     * Shard structure (each level depicts a stream segment):
+     * 0 1 2 3 4   5   - shards till epoch 102
+     * \ / \ / |   |
+     *  6   7  4   5   - shards from epoch 103 - 205
+     *  \  /   |  / \
+     *   8     4 9  10 - shards from epoch 206 (open - no ending sequenceNumber)
+     *
+     * Current leases: (4, 5, 7)
+     *
+     * If initial position is LATEST:
+     *   - New leases to create: (6)
+     * If initial position is TRIM_HORIZON:
+     *   - New leases to create: (0, 1)
+     * If initial position is AT_TIMESTAMP(epoch=200):
+     *   - New leases to create: (0, 1)
+     *
+     * The leases returned are sorted by the starting sequence number - following the same order
+     * when persisting the leases in DynamoDB will ensure that we recover gracefully if we fail
+     * before creating all the leases.
+     *
+     * If a shard has no existing lease, is open, and is a descendant of a parent which is still open, we ignore it
+     * here; this happens when the list of shards is inconsistent, which could be due to pagination delay for very
+     * high shard count streams (i.e., dynamodb streams for tables with thousands of partitions).  This can only
+     * currently happen here if ignoreUnexpectedChildShards was true in syncShardleases.
+     *
+     * @param shards List of all shards in Kinesis (we'll create new leases based on this set)
+     * @param currentLeases List of current leases
+     * @param initialPosition One of LATEST, TRIM_HORIZON, or AT_TIMESTAMP. We'll start fetching records from that
+     *        location in the shard (when an application starts up for the first time - and there are no checkpoints).
+     * @param inconsistentShardIds Set of child shard ids having open parents.
+     * @return List of new leases to create sorted by starting sequenceNumber of the corresponding shard
+     */
+    @Override
+    public List<KinesisClientLease> determineNewLeasesToCreate(List<Shard> shards,
+                                                               List<KinesisClientLease> currentLeases,
+                                                               InitialPositionInStreamExtended initialPosition,
+                                                               Set<String> inconsistentShardIds) {
+
+        Map<String, KinesisClientLease> shardIdToNewLeaseMap = new HashMap<>();
+        Map<String, Shard> shardIdToShardMapOfAllKinesisShards = KinesisShardSyncer.constructShardIdToShardMap(shards);
+
+        Set<String> shardIdsOfCurrentLeases = new HashSet<String>();
+        for (Lease lease : currentLeases) {
+            shardIdsOfCurrentLeases.add(lease.getLeaseKey());
+            LOG.debug("Existing lease: " + lease);
+        }
+
+        List<Shard> openShards = KinesisShardSyncer.getOpenShards(shards);
+        final KinesisShardSyncer.MemoizationContext memoizationContext = new KinesisShardSyncer.MemoizationContext();
+
+
+        // Iterate over the open shards and find those that don't have any lease entries.
+        for (Shard shard : openShards) {
+            String shardId = shard.getShardId();
+            LOG.debug("Evaluating leases for open shard " + shardId + " and its ancestors.");
+            if (shardIdsOfCurrentLeases.contains(shardId)) {
+                LOG.debug("Lease for shardId " + shardId + " already exists. Not creating a lease");
+            } else if (inconsistentShardIds.contains(shardId)) {
+                LOG.info("shardId " + shardId + " is an inconsistent child.  Not creating a lease");
+            } else {
+                LOG.debug("Beginning traversal of ancestry tree for shardId " + shardId);
+
+                // A shard is a descendant if at least one if its ancestors exists in the lease table.
+                // We will create leases for only one level in the ancestry tree. Once we find the first ancestor
+                // that needs to be processed in order to complete the hash range, we will not create leases for
+                // further descendants of that ancestor.
+                boolean isDescendant = KinesisShardSyncer.checkIfDescendantAndAddNewLeasesForAncestors(shardId,
+                        initialPosition, shardIdsOfCurrentLeases, shardIdToShardMapOfAllKinesisShards,
+                        shardIdToNewLeaseMap, memoizationContext);
+
+                // If shard is a descendant, the leases for its ancestors were already created above. Open shards
+                // that are NOT descendants will not have leases yet, so we create them here. We will not create
+                // leases for open shards that ARE descendants yet - leases for these shards will be created upon
+                // SHARD_END of their parents.
+                if (!isDescendant) {
+                    LOG.debug("ShardId " + shardId + " has no ancestors. Creating a lease.");
+                    final KinesisClientLease newLease = KinesisShardSyncer.newKCLLease(shard);
+                    newLease.setCheckpoint(KinesisShardSyncer.convertToCheckpoint(initialPosition));
+                    LOG.debug("Set checkpoint of " + newLease.getLeaseKey() + " to " + newLease.getCheckpoint());
+                    shardIdToNewLeaseMap.put(shardId, newLease);
+                } else {
+                    LOG.debug("ShardId " + shardId + " is a descendant whose ancestors should already have leases. " +
+                            "Not creating a lease.");
+                }
+            }
+        }
+
+        List<KinesisClientLease> newLeasesToCreate = new ArrayList<>();
+        newLeasesToCreate.addAll(shardIdToNewLeaseMap.values());
+        Comparator<? super KinesisClientLease> startingSequenceNumberComparator = new KinesisShardSyncer.StartingSequenceNumberAndShardIdBasedComparator(
+                shardIdToShardMapOfAllKinesisShards);
+        Collections.sort(newLeasesToCreate, startingSequenceNumberComparator);
+        return newLeasesToCreate;
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ParentsFirstShardPrioritization.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ParentsFirstShardPrioritization.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -25,6 +25,7 @@ import java.util.Map;
 * It also limits number of shards that will be available for initialization based on their depth.
 * It doesn't make a lot of sense to work on a shard that has too many unfinished parents.
 */
+@Deprecated
 public class ParentsFirstShardPrioritization implements
        ShardPrioritization {
    private static final SortingNode PROCESSING_NODE = new SortingNode(null, Integer.MIN_VALUE);
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PeriodicShardSyncManager.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PeriodicShardSyncManager.java
@ -0,0 +1,410 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import com.amazonaws.services.cloudwatch.model.StandardUnit;
+import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
+import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
+import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
+import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
+import com.amazonaws.services.kinesis.leases.impl.HashKeyRangeForLease;
+import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
+import com.amazonaws.services.kinesis.leases.impl.UpdateField;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
+import com.amazonaws.services.kinesis.metrics.impl.MetricsHelper;
+import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;
+import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
+import com.amazonaws.services.kinesis.model.Shard;
+import com.amazonaws.util.CollectionUtils;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ComparisonChain;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Value;
+import lombok.experimental.Accessors;
+import org.apache.commons.lang3.Validate;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import static com.amazonaws.services.kinesis.leases.impl.HashKeyRangeForLease.fromHashKeyRange;
+
+/**
+ * The top level orchestrator for coordinating the periodic shard sync related activities. If the configured
+ * {@link ShardSyncStrategyType} is PERIODIC, this class will be the main shard sync orchestrator. For non-PERIODIC
+ * strategies, this class will serve as an internal auditor that periodically checks if the full hash range is covered
+ * by currently held leases, and initiates a recovery shard sync if not.
+ */
+@Getter
+@EqualsAndHashCode
+class PeriodicShardSyncManager {
+    private static final Log LOG = LogFactory.getLog(PeriodicShardSyncManager.class);
+    private static final long INITIAL_DELAY = 0;
+
+    /** DEFAULT interval is used for PERIODIC {@link ShardSyncStrategyType}. */
+    private static final long DEFAULT_PERIODIC_SHARD_SYNC_INTERVAL_MILLIS = 1000L;
+
+    /** Parameters for validating hash range completeness when running in auditor mode. */
+    @VisibleForTesting
+    static final BigInteger MIN_HASH_KEY = BigInteger.ZERO;
+    @VisibleForTesting
+    static final BigInteger MAX_HASH_KEY = new BigInteger("2").pow(128).subtract(BigInteger.ONE);
+    static final String PERIODIC_SHARD_SYNC_MANAGER = "PeriodicShardSyncManager";
+    private final HashRangeHoleTracker hashRangeHoleTracker = new HashRangeHoleTracker();
+
+    private final String workerId;
+    private final LeaderDecider leaderDecider;
+    private final ITask metricsEmittingShardSyncTask;
+    private final ScheduledExecutorService shardSyncThreadPool;
+    private final ILeaseManager<KinesisClientLease> leaseManager;
+    private final IKinesisProxy kinesisProxy;
+    private final boolean isAuditorMode;
+    private final long periodicShardSyncIntervalMillis;
+    private boolean isRunning;
+    private final IMetricsFactory metricsFactory;
+    private final int leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+
+
+    PeriodicShardSyncManager(String workerId,
+                             LeaderDecider leaderDecider,
+                             ShardSyncTask shardSyncTask,
+                             IMetricsFactory metricsFactory,
+                             ILeaseManager<KinesisClientLease> leaseManager,
+                             IKinesisProxy kinesisProxy,
+                             boolean isAuditorMode,
+                             long leasesRecoveryAuditorExecutionFrequencyMillis,
+                             int leasesRecoveryAuditorInconsistencyConfidenceThreshold) {
+       this(workerId, leaderDecider, shardSyncTask, Executors.newSingleThreadScheduledExecutor(), metricsFactory,
+            leaseManager, kinesisProxy, isAuditorMode, leasesRecoveryAuditorExecutionFrequencyMillis,
+            leasesRecoveryAuditorInconsistencyConfidenceThreshold);
+    }
+
+    PeriodicShardSyncManager(String workerId,
+                             LeaderDecider leaderDecider,
+                             ShardSyncTask shardSyncTask,
+                             ScheduledExecutorService shardSyncThreadPool,
+                             IMetricsFactory metricsFactory,
+                             ILeaseManager<KinesisClientLease> leaseManager,
+                             IKinesisProxy kinesisProxy,
+                             boolean isAuditorMode,
+                             long leasesRecoveryAuditorExecutionFrequencyMillis,
+                             int leasesRecoveryAuditorInconsistencyConfidenceThreshold) {
+        Validate.notBlank(workerId, "WorkerID is required to initialize PeriodicShardSyncManager.");
+        Validate.notNull(leaderDecider, "LeaderDecider is required to initialize PeriodicShardSyncManager.");
+        Validate.notNull(shardSyncTask, "ShardSyncTask is required to initialize PeriodicShardSyncManager.");
+        this.workerId = workerId;
+        this.leaderDecider = leaderDecider;
+        this.metricsEmittingShardSyncTask = new MetricsCollectingTaskDecorator(shardSyncTask, metricsFactory);
+        this.shardSyncThreadPool = shardSyncThreadPool;
+        this.leaseManager = leaseManager;
+        this.kinesisProxy = kinesisProxy;
+        this.metricsFactory = metricsFactory;
+        this.isAuditorMode = isAuditorMode;
+        this.leasesRecoveryAuditorInconsistencyConfidenceThreshold = leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+        if (isAuditorMode) {
+            Validate.notNull(this.leaseManager, "LeaseManager is required for non-PERIODIC shard sync strategies.");
+            Validate.notNull(this.kinesisProxy, "KinesisProxy is required for non-PERIODIC shard sync strategies.");
+            this.periodicShardSyncIntervalMillis = leasesRecoveryAuditorExecutionFrequencyMillis;
+        } else {
+            this.periodicShardSyncIntervalMillis = DEFAULT_PERIODIC_SHARD_SYNC_INTERVAL_MILLIS;
+        }
+    }
+
+    public synchronized TaskResult start() {
+        if (!isRunning) {
+            final Runnable periodicShardSyncer = () -> {
+                try {
+                    runShardSync();
+                } catch (Throwable t) {
+                    LOG.error("Error running shard sync.", t);
+                }
+            };
+
+            shardSyncThreadPool
+                    .scheduleWithFixedDelay(periodicShardSyncer, INITIAL_DELAY, periodicShardSyncIntervalMillis,
+                            TimeUnit.MILLISECONDS);
+            isRunning = true;
+        }
+        return new TaskResult(null);
+    }
+
+    /**
+     * Runs ShardSync once, without scheduling further periodic ShardSyncs.
+     * @return TaskResult from shard sync
+     */
+    public synchronized TaskResult syncShardsOnce() {
+        LOG.info("Syncing shards once from worker " + workerId);
+        return metricsEmittingShardSyncTask.call();
+    }
+
+    public void stop() {
+        if (isRunning) {
+            LOG.info(String.format("Shutting down leader decider on worker %s", workerId));
+            leaderDecider.shutdown();
+            LOG.info(String.format("Shutting down periodic shard sync task scheduler on worker %s", workerId));
+            shardSyncThreadPool.shutdown();
+            isRunning = false;
+        }
+    }
+
+    private void runShardSync() {
+        if (leaderDecider.isLeader(workerId)) {
+            LOG.debug("WorkerId " + workerId + " is a leader, running the shard sync task");
+
+            MetricsHelper.startScope(metricsFactory, PERIODIC_SHARD_SYNC_MANAGER);
+            boolean isRunSuccess = false;
+            final long runStartMillis = System.currentTimeMillis();
+
+            try {
+                final ShardSyncResponse shardSyncResponse = checkForShardSync();
+                MetricsHelper.getMetricsScope().addData("NumStreamsToSync", shardSyncResponse.shouldDoShardSync() ? 1 : 0, StandardUnit.Count, MetricsLevel.SUMMARY);
+                MetricsHelper.getMetricsScope().addData("NumStreamsWithPartialLeases", shardSyncResponse.isHoleDetected() ? 1 : 0, StandardUnit.Count, MetricsLevel.SUMMARY);
+                if (shardSyncResponse.shouldDoShardSync()) {
+                    LOG.info("Periodic shard syncer initiating shard sync due to the reason - " +
+                            shardSyncResponse.reasonForDecision());
+                    metricsEmittingShardSyncTask.call();
+                } else {
+                    LOG.info("Skipping shard sync due to the reason - " + shardSyncResponse.reasonForDecision());
+                }
+                isRunSuccess = true;
+            } catch (Exception e) {
+                LOG.error("Caught exception while running periodic shard syncer.", e);
+            } finally {
+                MetricsHelper.addSuccessAndLatency(runStartMillis, isRunSuccess, MetricsLevel.SUMMARY);
+                MetricsHelper.endScope();
+            }
+        } else {
+            LOG.debug("WorkerId " + workerId + " is not a leader, not running the shard sync task");
+        }
+    }
+
+    @VisibleForTesting
+    ShardSyncResponse checkForShardSync() throws DependencyException, InvalidStateException,
+            ProvisionedThroughputException {
+
+        if (!isAuditorMode) {
+            // If we are running with PERIODIC shard sync strategy, we should sync every time.
+            return new ShardSyncResponse(true, false, "Syncing every time with PERIODIC shard sync strategy.");
+        }
+
+        // Get current leases from DynamoDB.
+        final List<KinesisClientLease> currentLeases = leaseManager.listLeases();
+
+        if (CollectionUtils.isNullOrEmpty(currentLeases)) {
+            // If the current leases are null or empty, then we need to initiate a shard sync.
+            LOG.info("No leases found. Will trigger a shard sync.");
+            return new ShardSyncResponse(true, false, "No leases found.");
+        }
+
+        // Check if there are any holes in the hash range covered by current leases. Return the first hole if present.
+        Optional<HashRangeHole> hashRangeHoleOpt = hasHoleInLeases(currentLeases);
+        if (hashRangeHoleOpt.isPresent()) {
+            // If hole is present, check if the hole is detected consecutively in previous occurrences. If hole is
+            // determined with high confidence, return true; return false otherwise. We use the high confidence factor
+            // to avoid shard sync on any holes during resharding and lease cleanups, or other intermittent issues.
+            final boolean hasHoleWithHighConfidence =
+                    hashRangeHoleTracker.hashHighConfidenceOfHoleWith(hashRangeHoleOpt.get());
+
+            return new ShardSyncResponse(hasHoleWithHighConfidence, true,
+                    "Detected the same hole for " + hashRangeHoleTracker.getNumConsecutiveHoles() + " times. " +
+                    "Will initiate shard sync after reaching threshold: " + leasesRecoveryAuditorInconsistencyConfidenceThreshold);
+        } else {
+            // If hole is not present, clear any previous hole tracking and return false.
+            hashRangeHoleTracker.reset();
+            return new ShardSyncResponse(false, false, "Hash range is complete.");
+        }
+    }
+
+    @VisibleForTesting
+    Optional<HashRangeHole> hasHoleInLeases(List<KinesisClientLease> leases) {
+        // Filter out any leases with checkpoints other than SHARD_END
+        final List<KinesisClientLease> activeLeases = leases.stream()
+                .filter(lease -> lease.getCheckpoint() != null && !lease.getCheckpoint().isShardEnd())
+                .collect(Collectors.toList());
+
+        final List<KinesisClientLease> activeLeasesWithHashRanges = fillWithHashRangesIfRequired(activeLeases);
+        return checkForHoleInHashKeyRanges(activeLeasesWithHashRanges);
+    }
+
+    private List<KinesisClientLease> fillWithHashRangesIfRequired(List<KinesisClientLease> activeLeases) {
+        final List<KinesisClientLease> activeLeasesWithNoHashRanges = activeLeases.stream()
+                .filter(lease -> lease.getHashKeyRange() == null).collect(Collectors.toList());
+
+        if (activeLeasesWithNoHashRanges.isEmpty()) {
+            return activeLeases;
+        }
+
+        // Fetch shards from Kinesis to fill in the in-memory hash ranges
+        final Map<String, Shard> kinesisShards = kinesisProxy.getShardList().stream()
+                .collect(Collectors.toMap(Shard::getShardId, shard -> shard));
+
+        return activeLeases.stream().map(lease -> {
+            if (lease.getHashKeyRange() == null) {
+                final String shardId = lease.getLeaseKey();
+                final Shard shard = kinesisShards.get(shardId);
+                if (shard == null) {
+                    return lease;
+                }
+                lease.setHashKeyRange(fromHashKeyRange(shard.getHashKeyRange()));
+
+                try {
+                    leaseManager.updateLeaseWithMetaInfo(lease, UpdateField.HASH_KEY_RANGE);
+                } catch (Exception e) {
+                    LOG.warn("Unable to update hash range information for lease " + lease.getLeaseKey() +
+                            ". This may result in explicit lease sync.");
+                }
+            }
+            return lease;
+        }).filter(lease -> lease.getHashKeyRange() != null).collect(Collectors.toList());
+    }
+
+    @VisibleForTesting
+    static Optional<HashRangeHole> checkForHoleInHashKeyRanges(List<KinesisClientLease> leasesWithHashKeyRanges) {
+        // Sort the hash ranges by starting hash key
+        final List<KinesisClientLease> sortedLeasesWithHashKeyRanges = sortLeasesByHashRange(leasesWithHashKeyRanges);
+        if (sortedLeasesWithHashKeyRanges.isEmpty()) {
+            LOG.error("No leases with valid hash ranges found.");
+            return Optional.of(new HashRangeHole());
+        }
+
+        // Validate the hash range bounds
+        final KinesisClientLease minHashKeyLease = sortedLeasesWithHashKeyRanges.get(0);
+        final KinesisClientLease maxHashKeyLease =
+                sortedLeasesWithHashKeyRanges.get(sortedLeasesWithHashKeyRanges.size() - 1);
+        if (!minHashKeyLease.getHashKeyRange().startingHashKey().equals(MIN_HASH_KEY) ||
+            !maxHashKeyLease.getHashKeyRange().endingHashKey().equals(MAX_HASH_KEY)) {
+            LOG.error("Incomplete hash range found between " + minHashKeyLease + " and " + maxHashKeyLease);
+            return Optional.of(new HashRangeHole(minHashKeyLease.getHashKeyRange(), maxHashKeyLease.getHashKeyRange()));
+        }
+
+        // Check for any holes in the sorted hash range intervals
+        if (sortedLeasesWithHashKeyRanges.size() > 1) {
+            KinesisClientLease leftmostLeaseToReportInCaseOfHole = minHashKeyLease;
+            HashKeyRangeForLease leftLeaseHashRange = leftmostLeaseToReportInCaseOfHole.getHashKeyRange();
+
+            for (int i = 1; i < sortedLeasesWithHashKeyRanges.size(); i++) {
+                final KinesisClientLease rightLease = sortedLeasesWithHashKeyRanges.get(i);
+                final HashKeyRangeForLease rightLeaseHashRange = rightLease.getHashKeyRange();
+                final BigInteger rangeDiff =
+                        rightLeaseHashRange.startingHashKey().subtract(leftLeaseHashRange.endingHashKey());
+                // We have overlapping leases when rangeDiff is 0 or negative.
+                // signum() will be -1 for negative and 0 if value is 0.
+                // Merge the ranges for further tracking.
+                if (rangeDiff.signum() <= 0) {
+                    leftLeaseHashRange = new HashKeyRangeForLease(leftLeaseHashRange.startingHashKey(),
+                            leftLeaseHashRange.endingHashKey().max(rightLeaseHashRange.endingHashKey()));
+                } else {
+                    // We have non-overlapping leases when rangeDiff is positive. signum() will be 1 in this case.
+                    // If rangeDiff is 1, then it is a continuous hash range. If not, there is a hole.
+                    if (!rangeDiff.equals(BigInteger.ONE)) {
+                        LOG.error("Incomplete hash range found between " + leftmostLeaseToReportInCaseOfHole +
+                                " and " + rightLease);
+                        return Optional.of(new HashRangeHole(leftmostLeaseToReportInCaseOfHole.getHashKeyRange(),
+                                rightLease.getHashKeyRange()));
+                    }
+
+                    leftmostLeaseToReportInCaseOfHole = rightLease;
+                    leftLeaseHashRange = rightLeaseHashRange;
+                }
+            }
+        }
+
+        return Optional.empty();
+    }
+
+    @VisibleForTesting
+    static List<KinesisClientLease> sortLeasesByHashRange(List<KinesisClientLease> leasesWithHashKeyRanges) {
+        if (leasesWithHashKeyRanges.size() == 0 || leasesWithHashKeyRanges.size() == 1) {
+            return leasesWithHashKeyRanges;
+        }
+        Collections.sort(leasesWithHashKeyRanges, new HashKeyRangeComparator());
+        return leasesWithHashKeyRanges;
+    }
+
+    @Value
+    @Accessors(fluent = true)
+    @VisibleForTesting
+    static class ShardSyncResponse {
+        private final boolean shouldDoShardSync;
+        private final boolean isHoleDetected;
+        private final String reasonForDecision;
+    }
+
+    @Value
+    private static class HashRangeHole {
+        private final HashKeyRangeForLease hashRangeAtStartOfPossibleHole;
+        private final HashKeyRangeForLease hashRangeAtEndOfPossibleHole;
+
+        HashRangeHole() {
+            hashRangeAtStartOfPossibleHole = hashRangeAtEndOfPossibleHole = null;
+        }
+
+        HashRangeHole(HashKeyRangeForLease hashRangeAtStartOfPossibleHole,
+                      HashKeyRangeForLease hashRangeAtEndOfPossibleHole) {
+            this.hashRangeAtStartOfPossibleHole = hashRangeAtStartOfPossibleHole;
+            this.hashRangeAtEndOfPossibleHole = hashRangeAtEndOfPossibleHole;
+        }
+    }
+
+    private class HashRangeHoleTracker {
+        private HashRangeHole hashRangeHole;
+        @Getter
+        private Integer numConsecutiveHoles;
+
+        public boolean hashHighConfidenceOfHoleWith(@NonNull HashRangeHole hashRangeHole) {
+            if (hashRangeHole.equals(this.hashRangeHole)) {
+                ++this.numConsecutiveHoles;
+            } else {
+                this.hashRangeHole = hashRangeHole;
+                this.numConsecutiveHoles = 1;
+            }
+
+            return numConsecutiveHoles >= leasesRecoveryAuditorInconsistencyConfidenceThreshold;
+        }
+
+        public void reset() {
+            this.hashRangeHole = null;
+            this.numConsecutiveHoles = 0;
+        }
+    }
+
+    private static class HashKeyRangeComparator implements Comparator<KinesisClientLease>, Serializable {
+        private static final long serialVersionUID = 1L;
+
+        @Override
+        public int compare(KinesisClientLease lease, KinesisClientLease otherLease) {
+            Validate.notNull(lease);
+            Validate.notNull(otherLease);
+            Validate.notNull(lease.getHashKeyRange());
+            Validate.notNull(otherLease.getHashKeyRange());
+            return ComparisonChain.start()
+                    .compare(lease.getHashKeyRange().startingHashKey(), otherLease.getHashKeyRange().startingHashKey())
+                    .compare(lease.getHashKeyRange().endingHashKey(), otherLease.getHashKeyRange().endingHashKey())
+                    .result();
+        }
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PeriodicShardSyncStrategy.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PeriodicShardSyncStrategy.java
@ -0,0 +1,44 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+
+/**
+ * An implementation of ShardSyncStrategy.
+ */
+class PeriodicShardSyncStrategy implements ShardSyncStrategy {
+
+    private IPeriodicShardSyncManager periodicShardSyncManager;
+
+    PeriodicShardSyncStrategy(IPeriodicShardSyncManager periodicShardSyncManager) {
+        this.periodicShardSyncManager = periodicShardSyncManager;
+    }
+
+    @Override
+    public ShardSyncStrategyType getStrategyType() {
+        return ShardSyncStrategyType.PERIODIC;
+    }
+
+    @Override
+    public TaskResult syncShards() {
+        return periodicShardSyncManager.start();
+    }
+
+    @Override
+    public TaskResult onWorkerInitialization() {
+        return syncShards();
+    }
+
+    @Override
+    public TaskResult onFoundCompletedShard() {
+        return new TaskResult(null);
+    }
+
+    @Override
+    public TaskResult onShardConsumerShutDown() {
+        return new TaskResult(null);
+    }
+
+    @Override
+    public void onWorkerShutDown() {
+        periodicShardSyncManager.stop();
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PrefetchGetRecordsCache.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PrefetchGetRecordsCache.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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. 
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
@ -20,7 +20,7 @@ import java.time.Instant;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;

-import org.apache.commons.lang.Validate;
+import org.apache.commons.lang3.Validate;

 import com.amazonaws.SdkClientException;
 import com.amazonaws.services.cloudwatch.model.StandardUnit;
@ -60,7 +60,7 @@ public class PrefetchGetRecordsCache implements GetRecordsCache {
    private PrefetchCounters prefetchCounters;
    private boolean started = false;
    private final String operation;
-    private final KinesisDataFetcher dataFetcher;
+    private final IDataFetcher dataFetcher;
    private final String shardId;

    /**
@ -129,6 +129,7 @@ public class PrefetchGetRecordsCache implements GetRecordsCache {
        try {
            result = getRecordsResultQueue.take().withCacheExitTime(Instant.now());
            prefetchCounters.removed(result);
+            log.info("Shard " + shardId + ": Number of records remaining in queue is " + getRecordsResultQueue.size());
        } catch (InterruptedException e) {
            log.error("Interrupted while getting records from the cache", e);
        }
@ -177,7 +178,6 @@ public class PrefetchGetRecordsCache implements GetRecordsCache {
                        
                        MetricsHelper.getMetricsScope().addData(EXPIRED_ITERATOR_METRIC, 1, StandardUnit.Count,
                                MetricsLevel.SUMMARY);
-                        
                        dataFetcher.restartIterator();
                    } catch (SdkClientException e) {
                        log.error("Exception thrown while fetching records from Kinesis", e);
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PreparedCheckpointer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/PreparedCheckpointer.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ProcessTask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ProcessTask.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -41,7 +41,7 @@ import com.amazonaws.services.kinesis.model.Shard;
 /**
 * Task for fetching data records and invoking processRecords() on the record processor instance.
 */
-class ProcessTask implements ITask {
+public class ProcessTask implements ITask {

    private static final Log LOG = LogFactory.getLog(ProcessTask.class);

@ -55,7 +55,7 @@ class ProcessTask implements ITask {
    private final ShardInfo shardInfo;
    private final IRecordProcessor recordProcessor;
    private final RecordProcessorCheckpointer recordProcessorCheckpointer;
-    private final KinesisDataFetcher dataFetcher;
+    private final IDataFetcher dataFetcher;
    private final TaskType taskType = TaskType.PROCESS;
    private final StreamConfig streamConfig;
    private final long backoffTimeMillis;
@ -81,7 +81,7 @@ class ProcessTask implements ITask {
     *            The retrieval strategy for fetching records from kinesis
     */
    public ProcessTask(ShardInfo shardInfo, StreamConfig streamConfig, IRecordProcessor recordProcessor,
-                       RecordProcessorCheckpointer recordProcessorCheckpointer, KinesisDataFetcher dataFetcher,
+                       RecordProcessorCheckpointer recordProcessorCheckpointer, IDataFetcher dataFetcher,
                       long backoffTimeMillis, boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
                       GetRecordsCache getRecordsCache) {
        this(shardInfo, streamConfig, recordProcessor, recordProcessorCheckpointer, dataFetcher, backoffTimeMillis,
@ -107,7 +107,7 @@ class ProcessTask implements ITask {
     *            determines how throttling events should be reported in the log.
     */
    public ProcessTask(ShardInfo shardInfo, StreamConfig streamConfig, IRecordProcessor recordProcessor,
-                       RecordProcessorCheckpointer recordProcessorCheckpointer, KinesisDataFetcher dataFetcher,
+                       RecordProcessorCheckpointer recordProcessorCheckpointer, IDataFetcher dataFetcher,
                       long backoffTimeMillis, boolean skipShardSyncAtWorkerInitializationIfLeasesExist,
                       ThrottlingReporter throttlingReporter, GetRecordsCache getRecordsCache) {
        super();
@ -152,8 +152,8 @@ class ProcessTask implements ITask {

        try {
            if (dataFetcher.isShardEndReached()) {
-                LOG.info("Reached end of shard " + shardInfo.getShardId());
-                return new TaskResult(null, true);
+                LOG.info("Reached end of shard " + shardInfo.getShardId() + ". Found childShards: " + dataFetcher.getChildShards());
+                return new TaskResult(null, true, dataFetcher.getChildShards());
            }

            final ProcessRecordsInput processRecordsInput = getRecordsResult();
@ -353,7 +353,7 @@ class ProcessTask implements ITask {
             * recordProcessorCheckpointer).
             */
            dataFetcher.advanceIteratorTo(recordProcessorCheckpointer.getLargestPermittedCheckpointValue()
-                    .getSequenceNumber(), streamConfig.getInitialPositionInStream());
+                                                                     .getSequenceNumber(), streamConfig.getInitialPositionInStream());

            // Try a second time - if we fail this time, expose the failure.
            try {
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/RecordProcessorCheckpointer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/RecordProcessorCheckpointer.java
@ -1,22 +1,19 @@
 /*
- * Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

-import com.amazonaws.services.kinesis.metrics.impl.MetricsHelper;
-import com.amazonaws.services.kinesis.metrics.impl.ThreadSafeMetricsDelegatingScope;
-import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

@ -37,7 +34,7 @@ import com.amazonaws.services.kinesis.model.Record;
 * The Amazon Kinesis Client Library will instantiate an object and provide a reference to the application
 * RecordProcessor instance. Amazon Kinesis Client Library will create one instance per shard assignment.
 */
-class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {
+public class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {

    private static final Log LOG = LogFactory.getLog(RecordProcessorCheckpointer.class);

@ -53,8 +50,6 @@ class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {
    private SequenceNumberValidator sequenceNumberValidator;

    private ExtendedSequenceNumber sequenceNumberAtShardEnd;
-    
-    private IMetricsFactory metricsFactory;

    /**
     * Only has package level access, since only the Amazon Kinesis Client Library should be creating these.
@ -62,14 +57,12 @@ class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {
     * @param checkpoint Used to checkpoint progress of a RecordProcessor
     * @param validator Used for validating sequence numbers
     */
-    RecordProcessorCheckpointer(ShardInfo shardInfo,
+    public RecordProcessorCheckpointer(ShardInfo shardInfo,
            ICheckpoint checkpoint,
-            SequenceNumberValidator validator,
-            IMetricsFactory metricsFactory) {
+            SequenceNumberValidator validator) {
        this.shardInfo = shardInfo;
        this.checkpoint = checkpoint;
        this.sequenceNumberValidator = validator;
-        this.metricsFactory = metricsFactory;
    }

    /**
@ -231,7 +224,7 @@ class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {
    /**
     * @return the lastCheckpointValue
     */
-    ExtendedSequenceNumber getLastCheckpointValue() {
+    public ExtendedSequenceNumber getLastCheckpointValue() {
        return lastCheckpointValue;
    }

@ -244,14 +237,14 @@ class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {
     *
     * @return the largest permitted checkpoint
     */
-    synchronized ExtendedSequenceNumber getLargestPermittedCheckpointValue() {
+    public synchronized ExtendedSequenceNumber getLargestPermittedCheckpointValue() {
        return largestPermittedCheckpointValue;
    }

    /**
     * @param largestPermittedCheckpointValue the largest permitted checkpoint
     */
-    synchronized void setLargestPermittedCheckpointValue(ExtendedSequenceNumber largestPermittedCheckpointValue) {
+    public synchronized void setLargestPermittedCheckpointValue(ExtendedSequenceNumber largestPermittedCheckpointValue) {
        this.largestPermittedCheckpointValue = largestPermittedCheckpointValue;
    }

@ -262,7 +255,7 @@ class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {
     *
     * @param extendedSequenceNumber
     */
-    synchronized void setSequenceNumberAtShardEnd(ExtendedSequenceNumber extendedSequenceNumber) {
+    public synchronized void setSequenceNumberAtShardEnd(ExtendedSequenceNumber extendedSequenceNumber) {
        this.sequenceNumberAtShardEnd = extendedSequenceNumber;
    }

@ -290,33 +283,22 @@ class RecordProcessorCheckpointer implements IRecordProcessorCheckpointer {
            // just checkpoint at SHARD_END
            checkpointToRecord = ExtendedSequenceNumber.SHARD_END;
        }
-        
-        boolean unsetMetrics = false;
+
        // Don't checkpoint a value we already successfully checkpointed
-        try {
-            if (!MetricsHelper.isMetricsScopePresent()) {
-                MetricsHelper.setMetricsScope(new ThreadSafeMetricsDelegatingScope(metricsFactory.createMetrics()));
-                unsetMetrics = true;
-            }
-            if (extendedSequenceNumber != null && !extendedSequenceNumber.equals(lastCheckpointValue)) {
-                try {
-                    if (LOG.isDebugEnabled()) {
-                        LOG.debug("Setting " + shardInfo.getShardId() + ", token " + shardInfo.getConcurrencyToken()
-                                + " checkpoint to " + checkpointToRecord);
-                    }
-                    checkpoint.setCheckpoint(shardInfo.getShardId(), checkpointToRecord, shardInfo.getConcurrencyToken());
-                    lastCheckpointValue = checkpointToRecord;
-                } catch (ThrottlingException | ShutdownException | InvalidStateException
-                        | KinesisClientLibDependencyException e) {
-                    throw e;
-                } catch (KinesisClientLibException e) {
-                    LOG.warn("Caught exception setting checkpoint.", e);
-                    throw new KinesisClientLibDependencyException("Caught exception while checkpointing", e);
+        if (extendedSequenceNumber != null && !extendedSequenceNumber.equals(lastCheckpointValue)) {
+            try {
+                if (LOG.isDebugEnabled()) {
+                    LOG.debug("Setting " + shardInfo.getShardId() + ", token " + shardInfo.getConcurrencyToken()
+                            + " checkpoint to " + checkpointToRecord);
                }
-            }
-        } finally {
-            if (unsetMetrics) {
-                MetricsHelper.unsetMetricsScope();
+                checkpoint.setCheckpoint(shardInfo.getShardId(), checkpointToRecord, shardInfo.getConcurrencyToken());
+                lastCheckpointValue = checkpointToRecord;
+            } catch (ThrottlingException | ShutdownException | InvalidStateException
+                     | KinesisClientLibDependencyException e) {
+                throw e;
+            } catch (KinesisClientLibException e) {
+                LOG.warn("Caught exception setting checkpoint.", e);
+                throw new KinesisClientLibDependencyException("Caught exception while checkpointing", e);
            }
        }
    }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/RecordsFetcherFactory.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/RecordsFetcherFactory.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/SequenceNumberValidator.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/SequenceNumberValidator.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -51,7 +51,7 @@ public class SequenceNumberValidator {
     * @param validateWithGetIterator Whether to attempt to get an iterator for this shard id and the sequence numbers
     *        being validated
     */
-    SequenceNumberValidator(IKinesisProxy proxy, String shardId, boolean validateWithGetIterator) {
+    public SequenceNumberValidator(IKinesisProxy proxy, String shardId, boolean validateWithGetIterator) {
        this.proxy = proxy;
        this.shardId = shardId;
        this.validateWithGetIterator = validateWithGetIterator;
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardConsumerShutdownNotification.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardConsumerShutdownNotification.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardEndShardSyncStrategy.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardEndShardSyncStrategy.java
@ -0,0 +1,76 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import com.amazonaws.services.kinesis.model.Shard;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Implementation of ShardSyncStrategy that facilitates shard syncs when a shard completes processing.
+ */
+class ShardEndShardSyncStrategy implements ShardSyncStrategy {
+
+    private static final Log LOG = LogFactory.getLog(Worker.class);
+    private ShardSyncTaskManager shardSyncTaskManager;
+
+    /** Runs periodic shard sync jobs in the background as an auditor process for shard-end syncs. */
+    private IPeriodicShardSyncManager periodicShardSyncManager;
+
+    ShardEndShardSyncStrategy(ShardSyncTaskManager shardSyncTaskManager,
+                              IPeriodicShardSyncManager periodicShardSyncManager) {
+        this.shardSyncTaskManager = shardSyncTaskManager;
+        this.periodicShardSyncManager = periodicShardSyncManager;
+    }
+
+    @Override
+    public ShardSyncStrategyType getStrategyType() {
+        return ShardSyncStrategyType.SHARD_END;
+    }
+
+    @Override
+    public TaskResult syncShards() {
+        Future<TaskResult> taskResultFuture = null;
+        TaskResult result = null;
+        while (taskResultFuture == null) {
+            taskResultFuture = shardSyncTaskManager.syncShardAndLeaseInfo(null);
+        }
+        try {
+            result = taskResultFuture.get();
+        } catch (InterruptedException | ExecutionException e) {
+            LOG.warn("ShardEndShardSyncStrategy syncShards encountered exception.", e);
+        }
+        return result;
+    }
+
+    @Override
+    public TaskResult onWorkerInitialization() {
+        LOG.info("Starting periodic shard sync background process for SHARD_END shard sync strategy.");
+        return periodicShardSyncManager.start();
+    }
+
+    @Override
+    public TaskResult onFoundCompletedShard() {
+        shardSyncTaskManager.syncShardAndLeaseInfo(null);
+        return new TaskResult(null);
+    }
+
+    @Override
+    public TaskResult onShardConsumerShutDown() {
+        return onFoundCompletedShard();
+    }
+
+    @Override
+    public TaskResult onShardConsumerShutDown(List<Shard> latestShards) {
+        shardSyncTaskManager.syncShardAndLeaseInfo(latestShards);
+        return new TaskResult(null);
+    }
+
+    @Override
+    public void onWorkerShutDown() {
+        LOG.info("Stopping periodic shard sync background process for SHARD_END shard sync strategy.");
+        periodicShardSyncManager.stop();
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardInfo.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardInfo.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -19,8 +19,8 @@ import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;

-import org.apache.commons.lang.builder.EqualsBuilder;
-import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;

 import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;

@ -86,7 +86,7 @@ public class ShardInfo {
     * 
     * @return a list of shardId's that are parents of this shard, or empty if the shard has no parents.
     */
-    protected List<String> getParentShardIds() {
+    public List<String> getParentShardIds() {
        return new LinkedList<String>(parentShardIds);
    }

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardPrioritization.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardPrioritization.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncStrategy.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncStrategy.java
@ -0,0 +1,62 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+import com.amazonaws.services.kinesis.model.Shard;
+
+import java.util.List;
+
+/**
+ * Facade of methods that can be invoked at different points
+ * in KCL application execution to perform certain actions related to shard-sync.
+ */
+public interface ShardSyncStrategy {
+
+    /**
+     * Can be used to provide a custom name for the implemented strategy.
+     *
+     * @return Name of the strategy.
+     */
+    ShardSyncStrategyType getStrategyType();
+
+    /**
+     * Invoked when the KCL application wants to execute shard-sync.
+     *
+     * @return TaskResult
+     */
+    TaskResult syncShards();
+
+    /**
+     * Invoked at worker initialization
+     *
+     * @return
+     */
+    TaskResult onWorkerInitialization();
+
+    /**
+     * Invoked when a completed shard is found.
+     *
+     * @return
+     */
+    TaskResult onFoundCompletedShard();
+
+    /**
+     * Invoked when ShardConsumer is shutdown.
+     *
+     * @return
+     */
+    TaskResult onShardConsumerShutDown();
+
+    /**
+     * Invoked when ShardConsumer is shutdown and all shards are provided.
+     *
+     * @param latestShards latest snapshot of shards to reuse
+     * @return
+     */
+    default TaskResult onShardConsumerShutDown(List<Shard> latestShards) {
+        return onShardConsumerShutDown();
+    }
+
+    /**
+     * Invoked when worker is shutdown.
+     */
+    void onWorkerShutDown();
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncStrategyType.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncStrategyType.java
@ -0,0 +1,12 @@
+package com.amazonaws.services.kinesis.clientlibrary.lib.worker;
+
+/**
+ * Types of ShardSyncStrategy} implemented in KCL.
+ */
+public enum ShardSyncStrategyType {
+
+    /* Shard sync are performed periodically */
+    PERIODIC,
+    /* Shard syncs are performed when processing of a shard completes */
+    SHARD_END
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncTask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncTask.java
@ -1,19 +1,20 @@
 /*
- * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

+import com.amazonaws.services.kinesis.model.Shard;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

@ -21,13 +22,15 @@ import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
 import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
 import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;

+import java.util.List;
+
 /**
 * This task syncs leases/activies with shards of the stream.
 * It will create new leases/activites when it discovers new shards (e.g. setup/resharding).
 * It will clean up leases/activities for shards that have been completely processed (if
 * cleanupLeasesUponShardCompletion is true).
 */
-class ShardSyncTask implements ITask {
+public class ShardSyncTask implements ITask {

    private static final Log LOG = LogFactory.getLog(ShardSyncTask.class);

@ -38,6 +41,8 @@ class ShardSyncTask implements ITask {
    private final boolean ignoreUnexpectedChildShards;
    private final long shardSyncTaskIdleTimeMillis;
    private final TaskType taskType = TaskType.SHARDSYNC;
+    private final ShardSyncer shardSyncer;
+    private final List<Shard> latestShards;

    /**
     * @param kinesisProxy Used to fetch information about the stream (e.g. shard list)
@ -45,19 +50,27 @@ class ShardSyncTask implements ITask {
     * @param initialPositionInStream One of LATEST, TRIM_HORIZON or AT_TIMESTAMP. Amazon Kinesis Client Library will
     *        start processing records from this point in the stream (when an application starts up for the first time)
     *        except for shards that already have a checkpoint (and their descendant shards).
+     * @param cleanupLeasesUponShardCompletion Clean up shards we've finished processing (don't wait for expiration
+     *        in Kinesis)
+     * @param shardSyncTaskIdleTimeMillis shardSync task idle time in millis
+     * @param shardSyncer shardSyncer instance used to check and create new leases
+     * @param latestShards latest snapshot of shards to reuse
     */
-    ShardSyncTask(IKinesisProxy kinesisProxy,
+    public ShardSyncTask(IKinesisProxy kinesisProxy,
            ILeaseManager<KinesisClientLease> leaseManager,
            InitialPositionInStreamExtended initialPositionInStream,
            boolean cleanupLeasesUponShardCompletion,
            boolean ignoreUnexpectedChildShards,
-            long shardSyncTaskIdleTimeMillis) {
+            long shardSyncTaskIdleTimeMillis,
+            ShardSyncer shardSyncer, List<Shard> latestShards) {
+        this.latestShards = latestShards;
        this.kinesisProxy = kinesisProxy;
        this.leaseManager = leaseManager;
        this.initialPosition = initialPositionInStream;
        this.cleanupLeasesUponShardCompletion = cleanupLeasesUponShardCompletion;
        this.ignoreUnexpectedChildShards = ignoreUnexpectedChildShards;
        this.shardSyncTaskIdleTimeMillis = shardSyncTaskIdleTimeMillis;
+        this.shardSyncer = shardSyncer;
    }

    /* (non-Javadoc)
@ -68,11 +81,12 @@ class ShardSyncTask implements ITask {
        Exception exception = null;

        try {
-            ShardSyncer.checkAndCreateLeasesForNewShards(kinesisProxy,
+            shardSyncer.checkAndCreateLeasesForNewShards(kinesisProxy,
                    leaseManager,
                    initialPosition,
                    cleanupLeasesUponShardCompletion,
-                    ignoreUnexpectedChildShards);
+                    ignoreUnexpectedChildShards,
+                    latestShards);
            if (shardSyncTaskIdleTimeMillis > 0) {
                Thread.sleep(shardSyncTaskIdleTimeMillis);
            }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncTaskManager.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncTaskManager.java
@ -1,24 +1,29 @@
 /*
- * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

-import java.util.Set;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;

+import com.amazonaws.services.kinesis.model.Shard;
+import lombok.Getter;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

@ -32,12 +37,12 @@ import com.amazonaws.services.kinesis.metrics.interfaces.IMetricsFactory;
 * Kinesis shards, remove obsolete leases). We'll have at most one outstanding sync task at any time.
 * Worker will use this class to kick off a sync task when it finds shards which have been completely processed.
 */
-class ShardSyncTaskManager {
+@Getter class ShardSyncTaskManager {

    private static final Log LOG = LogFactory.getLog(ShardSyncTaskManager.class);

    private ITask currentTask;
-    private Future<TaskResult> future;
+    private CompletableFuture<TaskResult> future;
    private final IKinesisProxy kinesisProxy;
    private final ILeaseManager<KinesisClientLease> leaseManager;
    private final IMetricsFactory metricsFactory;
@ -46,29 +51,30 @@ class ShardSyncTaskManager {
    private boolean cleanupLeasesUponShardCompletion;
    private boolean ignoreUnexpectedChildShards;
    private final long shardSyncIdleTimeMillis;
+    private final ShardSyncer shardSyncer;
+    private final ReentrantLock lock;

+    private AtomicBoolean shardSyncRequestPending;

    /**
     * Constructor.
-     * 
-     * @param kinesisProxy Proxy used to fetch streamInfo (shards)
-     * @param leaseManager Lease manager (used to list and create leases for shards)
-     * @param initialPositionInStream Initial position in stream
+     *
+     * @param kinesisProxy                     Proxy used to fetch streamInfo (shards)
+     * @param leaseManager                     Lease manager (used to list and create leases for shards)
+     * @param initialPositionInStream          Initial position in stream
     * @param cleanupLeasesUponShardCompletion Clean up leases for shards that we've finished processing (don't wait
-     *        until they expire)
-     * @param ignoreUnexpectedChildShards Ignore child shards with open parents
-     * @param shardSyncIdleTimeMillis Time between tasks to sync leases and Kinesis shards
-     * @param metricsFactory Metrics factory
-     * @param executorService ExecutorService to execute the shard sync tasks
+     *                                         until they expire)
+     * @param ignoreUnexpectedChildShards      Ignore child shards with open parents
+     * @param shardSyncIdleTimeMillis          Time between tasks to sync leases and Kinesis shards
+     * @param metricsFactory                   Metrics factory
+     * @param executorService                  ExecutorService to execute the shard sync tasks
+     * @param shardSyncer                      shardSyncer instance used to check and create new leases
     */
-    ShardSyncTaskManager(final IKinesisProxy kinesisProxy,
-            final ILeaseManager<KinesisClientLease> leaseManager,
+    ShardSyncTaskManager(final IKinesisProxy kinesisProxy, final ILeaseManager<KinesisClientLease> leaseManager,
            final InitialPositionInStreamExtended initialPositionInStream,
-            final boolean cleanupLeasesUponShardCompletion,
-            final boolean ignoreUnexpectedChildShards,
-            final long shardSyncIdleTimeMillis,
-            final IMetricsFactory metricsFactory,
-            ExecutorService executorService) {
+            final boolean cleanupLeasesUponShardCompletion, final boolean ignoreUnexpectedChildShards,
+            final long shardSyncIdleTimeMillis, final IMetricsFactory metricsFactory, ExecutorService executorService,
+            ShardSyncer shardSyncer) {
        this.kinesisProxy = kinesisProxy;
        this.leaseManager = leaseManager;
        this.metricsFactory = metricsFactory;
@ -77,14 +83,22 @@ class ShardSyncTaskManager {
        this.shardSyncIdleTimeMillis = shardSyncIdleTimeMillis;
        this.executorService = executorService;
        this.initialPositionInStream = initialPositionInStream;
+        this.shardSyncer = shardSyncer;
+        this.shardSyncRequestPending = new AtomicBoolean(false);
+        this.lock = new ReentrantLock();
    }

-    synchronized boolean syncShardAndLeaseInfo(Set<String> closedShardIds) {
-        return checkAndSubmitNextTask(closedShardIds);
+    Future<TaskResult> syncShardAndLeaseInfo(List<Shard> latestShards) {
+        try {
+            lock.lock();
+            return checkAndSubmitNextTask(latestShards);
+        } finally {
+            lock.unlock();
+        }
    }

-    private synchronized boolean checkAndSubmitNextTask(Set<String> closedShardIds) {
-        boolean submittedNewTask = false;
+    private Future<TaskResult> checkAndSubmitNextTask(List<Shard> latestShards) {
+        Future<TaskResult> submittedTaskFuture = null;
        if ((future == null) || future.isCancelled() || future.isDone()) {
            if ((future != null) && future.isDone()) {
                try {
@ -98,25 +112,48 @@ class ShardSyncTaskManager {
                }
            }

-            currentTask =
-                    new MetricsCollectingTaskDecorator(new ShardSyncTask(kinesisProxy,
-                            leaseManager,
-                            initialPositionInStream,
-                            cleanupLeasesUponShardCompletion,
-                            ignoreUnexpectedChildShards,
-                            shardSyncIdleTimeMillis), metricsFactory);
-            future = executorService.submit(currentTask);
-            submittedNewTask = true;
+            currentTask = new MetricsCollectingTaskDecorator(
+                    new ShardSyncTask(kinesisProxy, leaseManager, initialPositionInStream,
+                            cleanupLeasesUponShardCompletion, ignoreUnexpectedChildShards, shardSyncIdleTimeMillis,
+                            shardSyncer, latestShards), metricsFactory);
+            future = CompletableFuture.supplyAsync(() -> currentTask.call(), executorService)
+                    .whenComplete((taskResult, exception) -> handlePendingShardSyncs(exception, taskResult));
            if (LOG.isDebugEnabled()) {
                LOG.debug("Submitted new " + currentTask.getTaskType() + " task.");
            }
+            submittedTaskFuture = future;
        } else {
            if (LOG.isDebugEnabled()) {
-                LOG.debug("Previous " + currentTask.getTaskType() + " task still pending.  Not submitting new task.");
+                LOG.debug("Previous " + currentTask.getTaskType() + " task still pending.  Not submitting new task. "
+                        + "Enqueued a request that will be executed when the current request completes.");
            }
+            shardSyncRequestPending.compareAndSet(false /*expected*/, true /*update*/);
        }
-
-        return submittedNewTask;
+        return submittedTaskFuture;
    }

-}
+    private void handlePendingShardSyncs(Throwable exception, TaskResult taskResult) {
+        if (exception != null || taskResult.getException() != null) {
+            LOG.error("Caught exception running " + currentTask.getTaskType() + " task: ", exception != null ? exception : taskResult.getException());
+        }
+        // Acquire lock here. If shardSyncRequestPending is false in this completionStage and
+        // syncShardAndLeaseInfo is invoked, before completion stage exits (future completes)
+        // but right after the value of shardSyncRequestPending is checked, it will result in
+        // shardSyncRequestPending being set to true, but no pending futures to trigger the next
+        // ShardSyncTask. By executing this stage in a Reentrant lock, we ensure that if the
+        // previous task is in this completion stage, checkAndSubmitNextTask is not invoked
+        // until this completionStage exits.
+        try {
+            lock.lock();
+            if (shardSyncRequestPending.get()) {
+                shardSyncRequestPending.set(false);
+                // reset future to null, so next call creates a new one
+                // without trying to get results from the old future.
+                future = null;
+                checkAndSubmitNextTask(null);
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncer.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShardSyncer.java
@ -1,892 +1,43 @@
 /*
- * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

-import java.io.Serializable;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.apache.commons.lang.StringUtils;
-
 import com.amazonaws.services.kinesis.clientlibrary.exceptions.internal.KinesisClientLibIOException;
 import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
-import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;
 import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
 import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
 import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
 import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
 import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
-import com.amazonaws.services.kinesis.metrics.impl.MetricsHelper;
-import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
 import com.amazonaws.services.kinesis.model.Shard;

-/**
- * Helper class to sync leases with shards of the Kinesis stream.
- * It will create new leases/activities when it discovers new Kinesis shards (bootstrap/resharding).
- * It deletes leases for shards that have been trimmed from Kinesis, or if we've completed processing it
- * and begun processing it's child shards.
- */
-class ShardSyncer {
+import java.util.List;

-    private static final Log LOG = LogFactory.getLog(ShardSyncer.class);
+public interface ShardSyncer {

-    /**
-     * Note constructor is private: We use static synchronized methods - this is a utility class.
-     */
-    private ShardSyncer() {
+    void checkAndCreateLeasesForNewShards(IKinesisProxy kinesisProxy, ILeaseManager<KinesisClientLease> leaseManager,
+                                          InitialPositionInStreamExtended initialPositionInStream, boolean cleanupLeasesOfCompletedShards,
+                                          boolean ignoreUnexpectedChildShards)
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException,
+            KinesisClientLibIOException;
+
+    default void checkAndCreateLeasesForNewShards(IKinesisProxy kinesisProxy, ILeaseManager<KinesisClientLease> leaseManager,
+                                          InitialPositionInStreamExtended initialPositionInStream, boolean cleanupLeasesOfCompletedShards,
+                                          boolean ignoreUnexpectedChildShards, List<Shard> latestShards)
+            throws DependencyException, InvalidStateException, ProvisionedThroughputException,
+            KinesisClientLibIOException {
+        checkAndCreateLeasesForNewShards(kinesisProxy, leaseManager, initialPositionInStream, cleanupLeasesOfCompletedShards, ignoreUnexpectedChildShards);
    }
-
-    static synchronized void bootstrapShardLeases(IKinesisProxy kinesisProxy,
-            ILeaseManager<KinesisClientLease> leaseManager,
-            InitialPositionInStreamExtended initialPositionInStream,
-            boolean cleanupLeasesOfCompletedShards,
-            boolean ignoreUnexpectedChildShards)
-        throws DependencyException, InvalidStateException, ProvisionedThroughputException, KinesisClientLibIOException {
-        syncShardLeases(kinesisProxy, leaseManager, initialPositionInStream, cleanupLeasesOfCompletedShards,
-                        ignoreUnexpectedChildShards);
-    }
-
-    /**
-     * Check and create leases for any new shards (e.g. following a reshard operation).
-     * 
-     * @param kinesisProxy
-     * @param leaseManager
-     * @param initialPositionInStream
-     * @param cleanupLeasesOfCompletedShards
-     * @param ignoreUnexpectedChildShards
-     * @throws DependencyException
-     * @throws InvalidStateException
-     * @throws ProvisionedThroughputException
-     * @throws KinesisClientLibIOException
-     */
-    static synchronized void checkAndCreateLeasesForNewShards(IKinesisProxy kinesisProxy,
-            ILeaseManager<KinesisClientLease> leaseManager,
-            InitialPositionInStreamExtended initialPositionInStream,
-            boolean cleanupLeasesOfCompletedShards,
-            boolean ignoreUnexpectedChildShards)
-        throws DependencyException, InvalidStateException, ProvisionedThroughputException, KinesisClientLibIOException {
-        syncShardLeases(kinesisProxy, leaseManager, initialPositionInStream, cleanupLeasesOfCompletedShards, ignoreUnexpectedChildShards);
-    }
-
-    static synchronized void checkAndCreateLeasesForNewShards(IKinesisProxy kinesisProxy,
-            ILeaseManager<KinesisClientLease> leaseManager,
-            InitialPositionInStreamExtended initialPositionInStream,
-            boolean cleanupLeasesOfCompletedShards)
-        throws DependencyException, InvalidStateException, ProvisionedThroughputException, KinesisClientLibIOException {
-        checkAndCreateLeasesForNewShards(kinesisProxy, leaseManager, initialPositionInStream, cleanupLeasesOfCompletedShards, false);
-    }
-
-    /**
-     * Sync leases with Kinesis shards (e.g. at startup, or when we reach end of a shard).
-     * 
-     * @param kinesisProxy
-     * @param leaseManager
-     * @param initialPosition
-     * @param cleanupLeasesOfCompletedShards
-     * @param ignoreUnexpectedChildShards
-     * @throws DependencyException
-     * @throws InvalidStateException
-     * @throws ProvisionedThroughputException
-     * @throws KinesisClientLibIOException
-     */
-    // CHECKSTYLE:OFF CyclomaticComplexity
-    private static synchronized void syncShardLeases(IKinesisProxy kinesisProxy,
-            ILeaseManager<KinesisClientLease> leaseManager,
-            InitialPositionInStreamExtended initialPosition,
-            boolean cleanupLeasesOfCompletedShards,
-            boolean ignoreUnexpectedChildShards)
-        throws DependencyException, InvalidStateException, ProvisionedThroughputException, KinesisClientLibIOException {
-        List<Shard> shards = getShardList(kinesisProxy);
-        LOG.debug("Num shards: " + shards.size());
-
-        Map<String, Shard> shardIdToShardMap = constructShardIdToShardMap(shards);
-        Map<String, Set<String>> shardIdToChildShardIdsMap = constructShardIdToChildShardIdsMap(shardIdToShardMap);
-        Set<String> inconsistentShardIds = findInconsistentShardIds(shardIdToChildShardIdsMap, shardIdToShardMap);
-        if (!ignoreUnexpectedChildShards) {
-            assertAllParentShardsAreClosed(inconsistentShardIds);
-        }
-
-        List<KinesisClientLease> currentLeases = leaseManager.listLeases();
-
-        List<KinesisClientLease> newLeasesToCreate = determineNewLeasesToCreate(shards, currentLeases, initialPosition,
-                                                                                inconsistentShardIds);
-        LOG.debug("Num new leases to create: " + newLeasesToCreate.size());
-        for (KinesisClientLease lease : newLeasesToCreate) {
-            long startTimeMillis = System.currentTimeMillis();
-            boolean success = false;
-            try {
-                leaseManager.createLeaseIfNotExists(lease);
-                success = true;
-            } finally {
-                MetricsHelper.addSuccessAndLatency("CreateLease", startTimeMillis, success, MetricsLevel.DETAILED);
-            }
-        }
-        
-        List<KinesisClientLease> trackedLeases = new ArrayList<>();
-        if (currentLeases != null) {
-            trackedLeases.addAll(currentLeases);            
-        }
-        trackedLeases.addAll(newLeasesToCreate);
-        cleanupGarbageLeases(shards, trackedLeases, kinesisProxy, leaseManager);
-        if (cleanupLeasesOfCompletedShards) {
-            cleanupLeasesOfFinishedShards(currentLeases,
-                    shardIdToShardMap,
-                    shardIdToChildShardIdsMap,
-                    trackedLeases,
-                    leaseManager);
-        }
-    }
-    // CHECKSTYLE:ON CyclomaticComplexity
-
-    /** Helper method to detect a race condition between fetching the shards via paginated DescribeStream calls
-     * and a reshard operation.
-     * @param inconsistentShardIds
-     * @throws KinesisClientLibIOException
-     */
-    private static void assertAllParentShardsAreClosed(Set<String> inconsistentShardIds)
-        throws KinesisClientLibIOException {
-        if (!inconsistentShardIds.isEmpty()) {
-            String ids = StringUtils.join(inconsistentShardIds, ' ');
-            throw new KinesisClientLibIOException(String.format("%d open child shards (%s) are inconsistent. "
-                                                                + "This can happen due to a race condition between describeStream and a reshard operation.",
-                                                                inconsistentShardIds.size(), ids));
-        }
-    }
-
-    /**
-     * Helper method to construct the list of inconsistent shards, which are open shards with non-closed ancestor
-     * parent(s).
-     * @param shardIdToChildShardIdsMap
-     * @param shardIdToShardMap
-     * @return Set of inconsistent open shard ids for shards having open parents.
-     */
-    private static Set<String> findInconsistentShardIds(Map<String, Set<String>> shardIdToChildShardIdsMap,
-            Map<String, Shard> shardIdToShardMap) {
-        Set<String> result = new HashSet<String>();
-        for (String parentShardId : shardIdToChildShardIdsMap.keySet()) {
-            Shard parentShard = shardIdToShardMap.get(parentShardId);
-            if ((parentShardId == null) || (parentShard.getSequenceNumberRange().getEndingSequenceNumber() == null)) {
-                Set<String> childShardIdsMap = shardIdToChildShardIdsMap.get(parentShardId);
-                result.addAll(childShardIdsMap);
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Helper method to create a shardId->KinesisClientLease map.
-     * Note: This has package level access for testing purposes only.
-     * @param trackedLeaseList
-     * @return
-     */
-    static Map<String, KinesisClientLease> constructShardIdToKCLLeaseMap(List<KinesisClientLease> trackedLeaseList) {
-        Map<String, KinesisClientLease> trackedLeasesMap = new HashMap<>();
-        for (KinesisClientLease lease : trackedLeaseList) {
-            trackedLeasesMap.put(lease.getLeaseKey(), lease);
-        }
-        return trackedLeasesMap;
-    }
-
-    /**
-     * Note: this has package level access for testing purposes. 
-     * Useful for asserting that we don't have an incomplete shard list following a reshard operation.
-     * We verify that if the shard is present in the shard list, it is closed and its hash key range
-     *     is covered by its child shards.
-     * @param shards List of all Kinesis shards
-     * @param shardIdsOfClosedShards Id of the shard which is expected to be closed
-     * @return ShardIds of child shards (children of the expectedClosedShard)
-     * @throws KinesisClientLibIOException
-     */
-    static synchronized void assertClosedShardsAreCoveredOrAbsent(Map<String, Shard> shardIdToShardMap,
-            Map<String, Set<String>> shardIdToChildShardIdsMap,
-            Set<String> shardIdsOfClosedShards) throws KinesisClientLibIOException {        
-        String exceptionMessageSuffix = "This can happen if we constructed the list of shards "
-                        + " while a reshard operation was in progress.";
-        
-        for (String shardId : shardIdsOfClosedShards) {
-            Shard shard = shardIdToShardMap.get(shardId);
-            if (shard == null) {
-                LOG.info("Shard " + shardId + " is not present in Kinesis anymore.");
-                continue;
-            }
-            
-            String endingSequenceNumber = shard.getSequenceNumberRange().getEndingSequenceNumber();
-            if (endingSequenceNumber == null) {
-                throw new KinesisClientLibIOException("Shard " + shardIdsOfClosedShards
-                        + " is not closed. " + exceptionMessageSuffix);
-            }
-
-            Set<String> childShardIds = shardIdToChildShardIdsMap.get(shardId);
-            if (childShardIds == null) {
-                throw new KinesisClientLibIOException("Incomplete shard list: Closed shard " + shardId
-                        + " has no children." + exceptionMessageSuffix);
-            }
-
-            assertHashRangeOfClosedShardIsCovered(shard, shardIdToShardMap, childShardIds);
-        }
-    }
-
-    private static synchronized void assertHashRangeOfClosedShardIsCovered(Shard closedShard,
-            Map<String, Shard> shardIdToShardMap,
-            Set<String> childShardIds) throws KinesisClientLibIOException {
-        
-        BigInteger startingHashKeyOfClosedShard = new BigInteger(closedShard.getHashKeyRange().getStartingHashKey());
-        BigInteger endingHashKeyOfClosedShard = new BigInteger(closedShard.getHashKeyRange().getEndingHashKey());
-        BigInteger minStartingHashKeyOfChildren = null;
-        BigInteger maxEndingHashKeyOfChildren = null;
-
-        for (String childShardId : childShardIds) {
-            Shard childShard = shardIdToShardMap.get(childShardId);
-            BigInteger startingHashKey = new BigInteger(childShard.getHashKeyRange().getStartingHashKey());
-            if ((minStartingHashKeyOfChildren == null)
-                    || (startingHashKey.compareTo(minStartingHashKeyOfChildren) < 0)) {
-                minStartingHashKeyOfChildren = startingHashKey;
-            }
-            BigInteger endingHashKey = new BigInteger(childShard.getHashKeyRange().getEndingHashKey());
-            if ((maxEndingHashKeyOfChildren == null)
-                    || (endingHashKey.compareTo(maxEndingHashKeyOfChildren) > 0)) {
-                maxEndingHashKeyOfChildren = endingHashKey;
-            }
-        }
-        
-        if ((minStartingHashKeyOfChildren == null) || (maxEndingHashKeyOfChildren == null)
-                || (minStartingHashKeyOfChildren.compareTo(startingHashKeyOfClosedShard) > 0)
-                || (maxEndingHashKeyOfChildren.compareTo(endingHashKeyOfClosedShard) < 0)) {
-            throw new KinesisClientLibIOException("Incomplete shard list: hash key range of shard "
-                    + closedShard.getShardId() + " is not covered by its child shards.");
-        }
-        
-    }
-    
-    /**
-     * Helper method to construct shardId->setOfChildShardIds map.
-     * Note: This has package access for testing purposes only.
-     * @param shardIdToShardMap
-     * @return
-     */
-    static Map<String, Set<String>> constructShardIdToChildShardIdsMap(
-            Map<String, Shard> shardIdToShardMap) {
-        Map<String, Set<String>> shardIdToChildShardIdsMap = new HashMap<>();
-        for (Map.Entry<String, Shard> entry : shardIdToShardMap.entrySet()) {
-            String shardId = entry.getKey();
-            Shard shard = entry.getValue();
-            String parentShardId = shard.getParentShardId();
-            if ((parentShardId != null) && (shardIdToShardMap.containsKey(parentShardId))) {
-                Set<String> childShardIds = shardIdToChildShardIdsMap.get(parentShardId);
-                if (childShardIds == null) {
-                    childShardIds = new HashSet<String>();
-                    shardIdToChildShardIdsMap.put(parentShardId, childShardIds);
-                }
-                childShardIds.add(shardId);
-            }
-            
-            String adjacentParentShardId = shard.getAdjacentParentShardId();
-            if ((adjacentParentShardId != null) && (shardIdToShardMap.containsKey(adjacentParentShardId))) {
-                Set<String> childShardIds = shardIdToChildShardIdsMap.get(adjacentParentShardId);
-                if (childShardIds == null) {
-                    childShardIds = new HashSet<String>();
-                    shardIdToChildShardIdsMap.put(adjacentParentShardId, childShardIds);
-                }
-                childShardIds.add(shardId);
-            }
-        }
-        return shardIdToChildShardIdsMap;
-    }
-
-    private static List<Shard> getShardList(IKinesisProxy kinesisProxy) throws KinesisClientLibIOException {
-        List<Shard> shards = kinesisProxy.getShardList();
-        if (shards == null) {
-            throw new KinesisClientLibIOException(
-                    "Stream is not in ACTIVE OR UPDATING state - will retry getting the shard list.");
-        }
-        return shards;
-    }
-
-    /**
-     * Determine new leases to create and their initial checkpoint.
-     * Note: Package level access only for testing purposes.
-     *
-     * For each open (no ending sequence number) shard without open parents that doesn't already have a lease,
-     * determine if it is a descendent of any shard which is or will be processed (e.g. for which a lease exists):
-     * If so, set checkpoint of the shard to TrimHorizon and also create leases for ancestors if needed.
-     * If not, set checkpoint of the shard to the initial position specified by the client.
-     * To check if we need to create leases for ancestors, we use the following rules:
-     *   * If we began (or will begin) processing data for a shard, then we must reach end of that shard before
-     *         we begin processing data from any of its descendants.
-     *   * A shard does not start processing data until data from all its parents has been processed.
-     * Note, if the initial position is LATEST and a shard has two parents and only one is a descendant - we'll create
-     * leases corresponding to both the parents - the parent shard which is not a descendant will have  
-     * its checkpoint set to Latest.
-     * 
-     * We assume that if there is an existing lease for a shard, then either:
-     *   * we have previously created a lease for its parent (if it was needed), or
-     *   * the parent shard has expired.
-     * 
-     * For example:
-     * Shard structure (each level depicts a stream segment):
-     * 0 1 2 3 4   5   - shards till epoch 102
-     * \ / \ / |   |
-     *  6   7  4   5   - shards from epoch 103 - 205
-     *   \ /   |  / \
-     *    8    4 9  10 - shards from epoch 206 (open - no ending sequenceNumber)
-     * Current leases: (3, 4, 5)
-     * New leases to create: (2, 6, 7, 8, 9, 10)
-     * 
-     * The leases returned are sorted by the starting sequence number - following the same order
-     * when persisting the leases in DynamoDB will ensure that we recover gracefully if we fail
-     * before creating all the leases.
-     *
-     * If a shard has no existing lease, is open, and is a descendant of a parent which is still open, we ignore it
-     * here; this happens when the list of shards is inconsistent, which could be due to pagination delay for very
-     * high shard count streams (i.e., dynamodb streams for tables with thousands of partitions).  This can only
-     * currently happen here if ignoreUnexpectedChildShards was true in syncShardleases.
-     *
-     * 
-     * @param shards List of all shards in Kinesis (we'll create new leases based on this set)
-     * @param currentLeases List of current leases
-     * @param initialPosition One of LATEST, TRIM_HORIZON, or AT_TIMESTAMP. We'll start fetching records from that
-     *        location in the shard (when an application starts up for the first time - and there are no checkpoints).
-     * @param inconsistentShardIds Set of child shard ids having open parents.
-     * @return List of new leases to create sorted by starting sequenceNumber of the corresponding shard
-     */
-    static List<KinesisClientLease> determineNewLeasesToCreate(List<Shard> shards,
-            List<KinesisClientLease> currentLeases,
-            InitialPositionInStreamExtended initialPosition,
-            Set<String> inconsistentShardIds) {
-        Map<String, KinesisClientLease> shardIdToNewLeaseMap = new HashMap<String, KinesisClientLease>();
-        Map<String, Shard> shardIdToShardMapOfAllKinesisShards = constructShardIdToShardMap(shards);
-
-        Set<String> shardIdsOfCurrentLeases = new HashSet<String>();
-        for (KinesisClientLease lease : currentLeases) {
-            shardIdsOfCurrentLeases.add(lease.getLeaseKey());
-            LOG.debug("Existing lease: " + lease);
-        }
-
-        List<Shard> openShards = getOpenShards(shards);
-        Map<String, Boolean> memoizationContext = new HashMap<>();
-
-        // Iterate over the open shards and find those that don't have any lease entries.
-        for (Shard shard : openShards) {
-            String shardId = shard.getShardId();
-            LOG.debug("Evaluating leases for open shard " + shardId + " and its ancestors.");
-            if (shardIdsOfCurrentLeases.contains(shardId)) {
-                LOG.debug("Lease for shardId " + shardId + " already exists. Not creating a lease");
-            } else if (inconsistentShardIds.contains(shardId)) {
-                LOG.info("shardId " + shardId + " is an inconsistent child.  Not creating a lease");
-            } else {
-                LOG.debug("Need to create a lease for shardId " + shardId);
-                KinesisClientLease newLease = newKCLLease(shard);
-                boolean isDescendant =
-                        checkIfDescendantAndAddNewLeasesForAncestors(shardId,
-                                initialPosition,
-                                shardIdsOfCurrentLeases,
-                                shardIdToShardMapOfAllKinesisShards,
-                                shardIdToNewLeaseMap,
-                                memoizationContext);
-
-                /**
-                 * If the shard is a descendant and the specified initial position is AT_TIMESTAMP, then the
-                 * checkpoint should be set to AT_TIMESTAMP, else to TRIM_HORIZON. For AT_TIMESTAMP, we will add a
-                 * lease just like we do for TRIM_HORIZON. However we will only return back records with server-side
-                 * timestamp at or after the specified initial position timestamp.
-                 *
-                 * Shard structure (each level depicts a stream segment):
-                 * 0 1 2 3 4   5   - shards till epoch 102
-                 * \ / \ / |   |
-                 *  6   7  4   5   - shards from epoch 103 - 205
-                 *   \ /   |  /\
-                 *    8    4 9  10 - shards from epoch 206 (open - no ending sequenceNumber)
-                 *
-                 * Current leases: empty set
-                 *
-                 * For the above example, suppose the initial position in stream is set to AT_TIMESTAMP with
-                 * timestamp value 206. We will then create new leases for all the shards (with checkpoint set to
-                 * AT_TIMESTAMP), including the ancestor shards with epoch less than 206. However as we begin
-                 * processing the ancestor shards, their checkpoints would be updated to SHARD_END and their leases
-                 * would then be deleted since they won't have records with server-side timestamp at/after 206. And
-                 * after that we will begin processing the descendant shards with epoch at/after 206 and we will
-                 * return the records that meet the timestamp requirement for these shards.
-                 */
-                if (isDescendant && !initialPosition.getInitialPositionInStream()
-                        .equals(InitialPositionInStream.AT_TIMESTAMP)) {
-                    newLease.setCheckpoint(ExtendedSequenceNumber.TRIM_HORIZON);
-                } else {
-                    newLease.setCheckpoint(convertToCheckpoint(initialPosition));
-                }
-                LOG.debug("Set checkpoint of " + newLease.getLeaseKey() + " to " + newLease.getCheckpoint());
-                shardIdToNewLeaseMap.put(shardId, newLease);
-            }
-        }
-
-        List<KinesisClientLease> newLeasesToCreate = new ArrayList<KinesisClientLease>();
-        newLeasesToCreate.addAll(shardIdToNewLeaseMap.values());
-        Comparator<? super KinesisClientLease> startingSequenceNumberComparator =
-                new StartingSequenceNumberAndShardIdBasedComparator(shardIdToShardMapOfAllKinesisShards);
-        Collections.sort(newLeasesToCreate, startingSequenceNumberComparator);
-        return newLeasesToCreate;
-    }
-
-    /**
-     * Determine new leases to create and their initial checkpoint.
-     * Note: Package level access only for testing purposes.
-     */
-    static List<KinesisClientLease> determineNewLeasesToCreate(List<Shard> shards,
-            List<KinesisClientLease> currentLeases,
-            InitialPositionInStreamExtended initialPosition) {
-        Set<String> inconsistentShardIds = new HashSet<String>();
-        return determineNewLeasesToCreate(shards, currentLeases, initialPosition, inconsistentShardIds);
-    }
-
-    /**
-     * Note: Package level access for testing purposes only.
-     * Check if this shard is a descendant of a shard that is (or will be) processed.
-     * Create leases for the ancestors of this shard as required.
-     * See javadoc of determineNewLeasesToCreate() for rules and example.
-     * 
-     * @param shardId The shardId to check.
-     * @param initialPosition One of LATEST, TRIM_HORIZON, or AT_TIMESTAMP. We'll start fetching records from that
-     *        location in the shard (when an application starts up for the first time - and there are no checkpoints).
-     * @param shardIdsOfCurrentLeases The shardIds for the current leases.
-     * @param shardIdToShardMapOfAllKinesisShards ShardId->Shard map containing all shards obtained via DescribeStream.
-     * @param shardIdToLeaseMapOfNewShards Add lease POJOs corresponding to ancestors to this map.
-     * @param memoizationContext Memoization of shards that have been evaluated as part of the evaluation
-     * @return true if the shard is a descendant of any current shard (lease already exists)
-     */
-    // CHECKSTYLE:OFF CyclomaticComplexity
-    static boolean checkIfDescendantAndAddNewLeasesForAncestors(String shardId,
-            InitialPositionInStreamExtended initialPosition,
-            Set<String> shardIdsOfCurrentLeases,
-            Map<String, Shard> shardIdToShardMapOfAllKinesisShards,
-            Map<String, KinesisClientLease> shardIdToLeaseMapOfNewShards,
-            Map<String, Boolean> memoizationContext) {
-        
-        Boolean previousValue = memoizationContext.get(shardId);
-        if (previousValue != null) {
-            return previousValue;
-        }
-
-        boolean isDescendant = false;
-        Shard shard;
-        Set<String> parentShardIds;
-        Set<String> descendantParentShardIds = new HashSet<String>();
-
-        if ((shardId != null) && (shardIdToShardMapOfAllKinesisShards.containsKey(shardId))) {
-            if (shardIdsOfCurrentLeases.contains(shardId)) {
-                // This shard is a descendant of a current shard.
-                isDescendant = true;
-                // We don't need to add leases of its ancestors,
-                // because we'd have done it when creating a lease for this shard.
-            } else {
-                shard = shardIdToShardMapOfAllKinesisShards.get(shardId);
-                parentShardIds = getParentShardIds(shard, shardIdToShardMapOfAllKinesisShards);
-                for (String parentShardId : parentShardIds) {
-                    // Check if the parent is a descendant, and include its ancestors.
-                    if (checkIfDescendantAndAddNewLeasesForAncestors(parentShardId,
-                            initialPosition,
-                            shardIdsOfCurrentLeases,
-                            shardIdToShardMapOfAllKinesisShards,
-                            shardIdToLeaseMapOfNewShards,
-                            memoizationContext)) {
-                        isDescendant = true;
-                        descendantParentShardIds.add(parentShardId);
-                        LOG.debug("Parent shard " + parentShardId + " is a descendant.");
-                    } else {
-                        LOG.debug("Parent shard " + parentShardId + " is NOT a descendant.");
-                    }
-                }
-
-                // If this is a descendant, create leases for its parent shards (if they don't exist)
-                if (isDescendant) {
-                    for (String parentShardId : parentShardIds) {
-                        if (!shardIdsOfCurrentLeases.contains(parentShardId)) {
-                            LOG.debug("Need to create a lease for shardId " + parentShardId);
-                            KinesisClientLease lease = shardIdToLeaseMapOfNewShards.get(parentShardId);
-                            if (lease == null) {
-                                lease = newKCLLease(shardIdToShardMapOfAllKinesisShards.get(parentShardId));
-                                shardIdToLeaseMapOfNewShards.put(parentShardId, lease);
-                            }
-
-                            if (descendantParentShardIds.contains(parentShardId)
-                                    && !initialPosition.getInitialPositionInStream()
-                                        .equals(InitialPositionInStream.AT_TIMESTAMP)) {
-                                lease.setCheckpoint(ExtendedSequenceNumber.TRIM_HORIZON);
-                            } else {
-                                lease.setCheckpoint(convertToCheckpoint(initialPosition));
-                            }
-                        }
-                    }
-                } else {
-                    // This shard should be included, if the customer wants to process all records in the stream or
-                    // if the initial position is AT_TIMESTAMP. For AT_TIMESTAMP, we will add a lease just like we do
-                    // for TRIM_HORIZON. However we will only return back records with server-side timestamp at or
-                    // after the specified initial position timestamp.
-                    if (initialPosition.getInitialPositionInStream().equals(InitialPositionInStream.TRIM_HORIZON)
-                            || initialPosition.getInitialPositionInStream()
-                                .equals(InitialPositionInStream.AT_TIMESTAMP)) {
-                        isDescendant = true;
-                    }
-                }
-
-            }
-        }
-
-        memoizationContext.put(shardId, isDescendant);
-        return isDescendant;
-    }
-    // CHECKSTYLE:ON CyclomaticComplexity
-
-    /**
-     * Helper method to get parent shardIds of the current shard - includes the parent shardIds if:
-     * a/ they are not null
-     * b/ if they exist in the current shard map (i.e. haven't expired)
-     * 
-     * @param shard Will return parents of this shard
-     * @param shardIdToShardMapOfAllKinesisShards ShardId->Shard map containing all shards obtained via DescribeStream.
-     * @return Set of parentShardIds
-     */
-    static Set<String> getParentShardIds(Shard shard, Map<String, Shard> shardIdToShardMapOfAllKinesisShards) {
-        Set<String> parentShardIds = new HashSet<String>(2);
-        String parentShardId = shard.getParentShardId();
-        if ((parentShardId != null) && shardIdToShardMapOfAllKinesisShards.containsKey(parentShardId)) {
-            parentShardIds.add(parentShardId);
-        }
-        String adjacentParentShardId = shard.getAdjacentParentShardId();
-        if ((adjacentParentShardId != null) && shardIdToShardMapOfAllKinesisShards.containsKey(adjacentParentShardId)) {
-            parentShardIds.add(adjacentParentShardId);
-        }
-        return parentShardIds;
-    }
-
-    /**
-     * Delete leases corresponding to shards that no longer exist in the stream. 
-     * Current scheme: Delete a lease if:
-     *   * the corresponding shard is not present in the list of Kinesis shards, AND
-     *   * the parentShardIds listed in the lease are also not present in the list of Kinesis shards.
-     * @param shards List of all Kinesis shards (assumed to be a consistent snapshot - when stream is in Active state).
-     * @param trackedLeases List of 
-     * @param kinesisProxy Kinesis proxy (used to get shard list)
-     * @param leaseManager 
-     * @throws KinesisClientLibIOException Thrown if we couldn't get a fresh shard list from Kinesis.
-     * @throws ProvisionedThroughputException 
-     * @throws InvalidStateException 
-     * @throws DependencyException 
-     */
-    private static void cleanupGarbageLeases(List<Shard> shards,
-            List<KinesisClientLease> trackedLeases,
-            IKinesisProxy kinesisProxy,
-            ILeaseManager<KinesisClientLease> leaseManager)
-        throws KinesisClientLibIOException, DependencyException, InvalidStateException, ProvisionedThroughputException {
-        Set<String> kinesisShards = new HashSet<>();
-        for (Shard shard : shards) {
-            kinesisShards.add(shard.getShardId());
-        }
-        
-        // Check if there are leases for non-existent shards
-        List<KinesisClientLease> garbageLeases = new ArrayList<>();
-        for (KinesisClientLease lease : trackedLeases) {
-            if (isCandidateForCleanup(lease, kinesisShards)) {
-                garbageLeases.add(lease);
-            }
-        }
-        
-        if (!garbageLeases.isEmpty()) {
-            LOG.info("Found " + garbageLeases.size()
-                    + " candidate leases for cleanup. Refreshing list of" 
-                    + " Kinesis shards to pick up recent/latest shards");
-            List<Shard> currentShardList = getShardList(kinesisProxy);
-            Set<String> currentKinesisShardIds = new HashSet<>();
-            for (Shard shard : currentShardList) {
-                currentKinesisShardIds.add(shard.getShardId());
-            }
-
-            for (KinesisClientLease lease : garbageLeases) {
-                if (isCandidateForCleanup(lease, currentKinesisShardIds)) {
-                    LOG.info("Deleting lease for shard " + lease.getLeaseKey()
-                            + " as it is not present in Kinesis stream.");
-                    leaseManager.deleteLease(lease);
-                }
-            }
-        }
-        
-    }
-
-    /**
-     * Note: This method has package level access, solely for testing purposes.
-     * 
-     * @param lease Candidate shard we are considering for deletion.
-     * @param currentKinesisShardIds
-     * @return true if neither the shard (corresponding to the lease), nor its parents are present in
-     *         currentKinesisShardIds
-     * @throws KinesisClientLibIOException Thrown if currentKinesisShardIds contains a parent shard but not the child
-     *         shard (we are evaluating for deletion).
-     */
-    static boolean isCandidateForCleanup(KinesisClientLease lease, Set<String> currentKinesisShardIds)
-        throws KinesisClientLibIOException {
-        boolean isCandidateForCleanup = true;
-        
-        if (currentKinesisShardIds.contains(lease.getLeaseKey())) {
-            isCandidateForCleanup = false;
-        } else {
-            LOG.info("Found lease for non-existent shard: " + lease.getLeaseKey() + ". Checking its parent shards");
-            Set<String> parentShardIds = lease.getParentShardIds();
-            for (String parentShardId : parentShardIds) {
-                
-                // Throw an exception if the parent shard exists (but the child does not).
-                // This may be a (rare) race condition between fetching the shard list and Kinesis expiring shards. 
-                if (currentKinesisShardIds.contains(parentShardId)) {
-                    String message =
-                            "Parent shard " + parentShardId + " exists but not the child shard "
-                                    + lease.getLeaseKey();
-                    LOG.info(message);
-                    throw new KinesisClientLibIOException(message);
-                }
-            }
-        }
-
-        return isCandidateForCleanup;
-    }
-    
-    /**
-     * Private helper method.
-     * Clean up leases for shards that meet the following criteria:
-     * a/ the shard has been fully processed (checkpoint is set to SHARD_END)
-     * b/ we've begun processing all the child shards: we have leases for all child shards and their checkpoint is not
-     *      TRIM_HORIZON.
-     * 
-     * @param currentLeases List of leases we evaluate for clean up
-     * @param shardIdToShardMap Map of shardId->Shard (assumed to include all Kinesis shards)
-     * @param shardIdToChildShardIdsMap Map of shardId->childShardIds (assumed to include all Kinesis shards)
-     * @param trackedLeases List of all leases we are tracking.
-     * @param leaseManager Lease manager (will be used to delete leases)
-     * @throws DependencyException
-     * @throws InvalidStateException
-     * @throws ProvisionedThroughputException
-     * @throws KinesisClientLibIOException
-     */
-    private static synchronized void cleanupLeasesOfFinishedShards(Collection<KinesisClientLease> currentLeases,
-            Map<String, Shard> shardIdToShardMap,
-            Map<String, Set<String>> shardIdToChildShardIdsMap,
-            List<KinesisClientLease> trackedLeases,
-            ILeaseManager<KinesisClientLease> leaseManager)
-        throws DependencyException, InvalidStateException, ProvisionedThroughputException, KinesisClientLibIOException {
-        Set<String> shardIdsOfClosedShards = new HashSet<>();
-        List<KinesisClientLease> leasesOfClosedShards = new ArrayList<>();
-        for (KinesisClientLease lease : currentLeases) {
-            if (lease.getCheckpoint().equals(ExtendedSequenceNumber.SHARD_END)) {
-                shardIdsOfClosedShards.add(lease.getLeaseKey());
-                leasesOfClosedShards.add(lease);
-            }
-        }
-
-        if (!leasesOfClosedShards.isEmpty()) {
-            assertClosedShardsAreCoveredOrAbsent(shardIdToShardMap,
-                    shardIdToChildShardIdsMap,
-                    shardIdsOfClosedShards);
-            Comparator<? super KinesisClientLease> startingSequenceNumberComparator =
-                    new StartingSequenceNumberAndShardIdBasedComparator(shardIdToShardMap);
-            Collections.sort(leasesOfClosedShards, startingSequenceNumberComparator);
-            Map<String, KinesisClientLease> trackedLeaseMap = constructShardIdToKCLLeaseMap(trackedLeases);
-
-            for (KinesisClientLease leaseOfClosedShard : leasesOfClosedShards) {
-                String closedShardId = leaseOfClosedShard.getLeaseKey();
-                Set<String> childShardIds = shardIdToChildShardIdsMap.get(closedShardId);
-                if ((closedShardId != null) && (childShardIds != null) && (!childShardIds.isEmpty())) {
-                    cleanupLeaseForClosedShard(closedShardId, childShardIds, trackedLeaseMap, leaseManager);
-                }
-            }
-        }        
-    }
-
-    /** 
-     * Delete lease for the closed shard. Rules for deletion are:
-     * a/ the checkpoint for the closed shard is SHARD_END,
-     * b/ there are leases for all the childShardIds and their checkpoint is NOT TRIM_HORIZON
-     * Note: This method has package level access solely for testing purposes.
-     * 
-     * @param closedShardId Identifies the closed shard
-     * @param childShardIds ShardIds of children of the closed shard
-     * @param trackedLeases shardId->KinesisClientLease map with all leases we are tracking (should not be null)
-     * @param leaseManager 
-     * @throws ProvisionedThroughputException 
-     * @throws InvalidStateException 
-     * @throws DependencyException 
-     */
-    static synchronized void cleanupLeaseForClosedShard(String closedShardId,
-            Set<String> childShardIds,
-            Map<String, KinesisClientLease> trackedLeases,
-            ILeaseManager<KinesisClientLease> leaseManager)
-        throws DependencyException, InvalidStateException, ProvisionedThroughputException {
-        KinesisClientLease leaseForClosedShard = trackedLeases.get(closedShardId);
-        List<KinesisClientLease> childShardLeases = new ArrayList<>();
-        
-        for (String childShardId : childShardIds) {
-            KinesisClientLease childLease = trackedLeases.get(childShardId);
-            if (childLease != null) {
-                childShardLeases.add(childLease);
-            }
-        }
-        
-        if ((leaseForClosedShard != null)
-                && (leaseForClosedShard.getCheckpoint().equals(ExtendedSequenceNumber.SHARD_END))
-                && (childShardLeases.size() == childShardIds.size())) {
-            boolean okayToDelete = true;
-            for (KinesisClientLease lease : childShardLeases) {
-                if (lease.getCheckpoint().equals(ExtendedSequenceNumber.TRIM_HORIZON)) {
-                    okayToDelete = false;
-                    break;
-                }
-            }
-            
-            if (okayToDelete) {
-                LOG.info("Deleting lease for shard " + leaseForClosedShard.getLeaseKey()
-                        + " as it has been completely processed and processing of child shards has begun.");
-                leaseManager.deleteLease(leaseForClosedShard);
-            }
-        }
-    }
-
-    /**
-     * Helper method to create a new KinesisClientLease POJO for a shard.
-     * Note: Package level access only for testing purposes
-     * 
-     * @param shard
-     * @return
-     */
-    static KinesisClientLease newKCLLease(Shard shard) {
-        KinesisClientLease newLease = new KinesisClientLease();
-        newLease.setLeaseKey(shard.getShardId());
-        List<String> parentShardIds = new ArrayList<String>(2);
-        if (shard.getParentShardId() != null) {
-            parentShardIds.add(shard.getParentShardId());
-        }
-        if (shard.getAdjacentParentShardId() != null) {
-            parentShardIds.add(shard.getAdjacentParentShardId());
-        }
-        newLease.setParentShardIds(parentShardIds);
-        newLease.setOwnerSwitchesSinceCheckpoint(0L);
-
-        return newLease;
-    }
-
-    /**
-     * Helper method to construct a shardId->Shard map for the specified list of shards.
-     * 
-     * @param shards List of shards
-     * @return ShardId->Shard map
-     */
-    static Map<String, Shard> constructShardIdToShardMap(List<Shard> shards) {
-        Map<String, Shard> shardIdToShardMap = new HashMap<String, Shard>();
-        for (Shard shard : shards) {
-            shardIdToShardMap.put(shard.getShardId(), shard);
-        }
-        return shardIdToShardMap;
-    }
-
-    /**
-     * Helper method to return all the open shards for a stream.
-     * Note: Package level access only for testing purposes.
-     * 
-     * @param allShards All shards returved via DescribeStream. We assume this to represent a consistent shard list.
-     * @return List of open shards (shards at the tip of the stream) - may include shards that are not yet active.
-     */
-    static List<Shard> getOpenShards(List<Shard> allShards) {
-        List<Shard> openShards = new ArrayList<Shard>();
-        for (Shard shard : allShards) {
-            String endingSequenceNumber = shard.getSequenceNumberRange().getEndingSequenceNumber();
-            if (endingSequenceNumber == null) {
-                openShards.add(shard);
-                LOG.debug("Found open shard: " + shard.getShardId());
-            }
-        }
-        return openShards;
-    }
-
-    private static ExtendedSequenceNumber convertToCheckpoint(InitialPositionInStreamExtended position) {
-        ExtendedSequenceNumber checkpoint = null;
-        
-        if (position.getInitialPositionInStream().equals(InitialPositionInStream.TRIM_HORIZON)) {
-            checkpoint = ExtendedSequenceNumber.TRIM_HORIZON;
-        } else if (position.getInitialPositionInStream().equals(InitialPositionInStream.LATEST)) {
-            checkpoint = ExtendedSequenceNumber.LATEST;
-        } else if (position.getInitialPositionInStream().equals(InitialPositionInStream.AT_TIMESTAMP)) {
-            checkpoint = ExtendedSequenceNumber.AT_TIMESTAMP;
-        }
-        
-        return checkpoint;
-    }
-    
-    /** Helper class to compare leases based on starting sequence number of the corresponding shards.
-     *
-     */
-    private static class StartingSequenceNumberAndShardIdBasedComparator implements Comparator<KinesisClientLease>,
-            Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        private final Map<String, Shard> shardIdToShardMap;
-        
-        /**
-         * @param shardIdToShardMapOfAllKinesisShards
-         */
-        public StartingSequenceNumberAndShardIdBasedComparator(Map<String, Shard> shardIdToShardMapOfAllKinesisShards) {
-            shardIdToShardMap = shardIdToShardMapOfAllKinesisShards;
-        }
-
-        /**
-         * Compares two leases based on the starting sequence number of corresponding shards.
-         * If shards are not found in the shardId->shard map supplied, we do a string comparison on the shardIds.
-         * We assume that lease1 and lease2 are:
-         *     a/ not null,
-         *     b/ shards (if found) have non-null starting sequence numbers
-         * 
-         * {@inheritDoc}
-         */
-        @Override
-        public int compare(KinesisClientLease lease1, KinesisClientLease lease2) {
-            int result = 0;
-            String shardId1 = lease1.getLeaseKey();
-            String shardId2 = lease2.getLeaseKey();
-            Shard shard1 = shardIdToShardMap.get(shardId1);
-            Shard shard2 = shardIdToShardMap.get(shardId2);
-            
-            // If we found shards for the two leases, use comparison of the starting sequence numbers
-            if ((shard1 != null) && (shard2 != null)) {
-                BigInteger sequenceNumber1 =
-                        new BigInteger(shard1.getSequenceNumberRange().getStartingSequenceNumber());
-                BigInteger sequenceNumber2 =
-                        new BigInteger(shard2.getSequenceNumberRange().getStartingSequenceNumber());
-                result = sequenceNumber1.compareTo(sequenceNumber2);                
-            }
-            
-            if (result == 0) {
-                result = shardId1.compareTo(shardId2);
-            }
-            
-            return result;
-        }
-                
-    }
-
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownNotification.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownNotification.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownNotificationTask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownNotificationTask.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -21,14 +21,14 @@ import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IShutdownNotif
 /**
 * Notifies record processor of incoming shutdown request, and gives them a chance to checkpoint.
 */
-class ShutdownNotificationTask implements ITask {
+public class ShutdownNotificationTask implements ITask {

    private final IRecordProcessor recordProcessor;
    private final IRecordProcessorCheckpointer recordProcessorCheckpointer;
    private final ShutdownNotification shutdownNotification;
    private final ShardInfo shardInfo;

-    ShutdownNotificationTask(IRecordProcessor recordProcessor, IRecordProcessorCheckpointer recordProcessorCheckpointer, ShutdownNotification shutdownNotification, ShardInfo shardInfo) {
+    public ShutdownNotificationTask(IRecordProcessor recordProcessor, IRecordProcessorCheckpointer recordProcessorCheckpointer, ShutdownNotification shutdownNotification, ShardInfo shardInfo) {
        this.recordProcessor = recordProcessor;
        this.recordProcessorCheckpointer = recordProcessorCheckpointer;
        this.shutdownNotification = shutdownNotification;
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownReason.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownReason.java
@ -1,22 +1,22 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

 import com.amazonaws.services.kinesis.clientlibrary.types.ShutdownInput;
-import static com.amazonaws.services.kinesis.clientlibrary.lib.worker.ConsumerStates.ConsumerState;
-import static com.amazonaws.services.kinesis.clientlibrary.lib.worker.ConsumerStates.ShardConsumerState;
+import static com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisConsumerStates.ConsumerState;
+import static com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisConsumerStates.ShardConsumerState;


 /**
@ -72,7 +72,7 @@ public enum ShutdownReason {
        return reason.rank > this.rank;
    }

-    ConsumerState getShutdownState() {
+    public ConsumerState getShutdownState() {
        return shutdownState;
    }
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownTask.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ShutdownTask.java
@ -1,172 +0,0 @@
-/*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
- *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-
-import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessor;
-import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
-import com.amazonaws.services.kinesis.clientlibrary.types.ExtendedSequenceNumber;
-import com.amazonaws.services.kinesis.clientlibrary.types.ShutdownInput;
-import com.amazonaws.services.kinesis.leases.impl.KinesisClientLease;
-import com.amazonaws.services.kinesis.leases.interfaces.ILeaseManager;
-import com.amazonaws.services.kinesis.metrics.impl.MetricsHelper;
-import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
-import com.google.common.annotations.VisibleForTesting;
-
-/**
- * Task for invoking the RecordProcessor shutdown() callback.
- */
-class ShutdownTask implements ITask {
-
-    private static final Log LOG = LogFactory.getLog(ShutdownTask.class);
-
-    private static final String RECORD_PROCESSOR_SHUTDOWN_METRIC = "RecordProcessor.shutdown";
-
-    private final ShardInfo shardInfo;
-    private final IRecordProcessor recordProcessor;
-    private final RecordProcessorCheckpointer recordProcessorCheckpointer;
-    private final ShutdownReason reason;
-    private final IKinesisProxy kinesisProxy;
-    private final ILeaseManager<KinesisClientLease> leaseManager;
-    private final InitialPositionInStreamExtended initialPositionInStream;
-    private final boolean cleanupLeasesOfCompletedShards;
-    private final boolean ignoreUnexpectedChildShards;
-    private final TaskType taskType = TaskType.SHUTDOWN;
-    private final long backoffTimeMillis;
-    private final GetRecordsCache getRecordsCache;
-
-    /**
-     * Constructor.
-     */
-    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 10 LINES
-    ShutdownTask(ShardInfo shardInfo,
-                 IRecordProcessor recordProcessor,
-                 RecordProcessorCheckpointer recordProcessorCheckpointer,
-                 ShutdownReason reason,
-                 IKinesisProxy kinesisProxy,
-                 InitialPositionInStreamExtended initialPositionInStream,
-                 boolean cleanupLeasesOfCompletedShards,
-                 boolean ignoreUnexpectedChildShards,
-                 ILeaseManager<KinesisClientLease> leaseManager,
-                 long backoffTimeMillis, 
-                 GetRecordsCache getRecordsCache) {
-        this.shardInfo = shardInfo;
-        this.recordProcessor = recordProcessor;
-        this.recordProcessorCheckpointer = recordProcessorCheckpointer;
-        this.reason = reason;
-        this.kinesisProxy = kinesisProxy;
-        this.initialPositionInStream = initialPositionInStream;
-        this.cleanupLeasesOfCompletedShards = cleanupLeasesOfCompletedShards;
-        this.ignoreUnexpectedChildShards = ignoreUnexpectedChildShards;
-        this.leaseManager = leaseManager;
-        this.backoffTimeMillis = backoffTimeMillis;
-        this.getRecordsCache = getRecordsCache;
-    }
-
-    /*
-     * Invokes RecordProcessor shutdown() API.
-     * (non-Javadoc)
-     * 
-     * @see com.amazonaws.services.kinesis.clientlibrary.lib.worker.ITask#call()
-     */
-    @Override
-    public TaskResult call() {
-        Exception exception;
-        boolean applicationException = false;
-
-        try {
-            // If we reached end of the shard, set sequence number to SHARD_END.
-            if (reason == ShutdownReason.TERMINATE) {
-                recordProcessorCheckpointer.setSequenceNumberAtShardEnd(
-                        recordProcessorCheckpointer.getLargestPermittedCheckpointValue());
-                recordProcessorCheckpointer.setLargestPermittedCheckpointValue(ExtendedSequenceNumber.SHARD_END);
-            }
-
-            LOG.debug("Invoking shutdown() for shard " + shardInfo.getShardId() + ", concurrencyToken "
-                    + shardInfo.getConcurrencyToken() + ". Shutdown reason: " + reason);
-            final ShutdownInput shutdownInput = new ShutdownInput()
-                    .withShutdownReason(reason)
-                    .withCheckpointer(recordProcessorCheckpointer);
-            final long recordProcessorStartTimeMillis = System.currentTimeMillis();
-            try {
-                recordProcessor.shutdown(shutdownInput);
-                ExtendedSequenceNumber lastCheckpointValue = recordProcessorCheckpointer.getLastCheckpointValue();
-
-                if (reason == ShutdownReason.TERMINATE) {
-                    if ((lastCheckpointValue == null)
-                            || (!lastCheckpointValue.equals(ExtendedSequenceNumber.SHARD_END))) {
-                        throw new IllegalArgumentException("Application didn't checkpoint at end of shard "
-                                + shardInfo.getShardId());
-                    }
-                }
-                LOG.debug("Shutting down retrieval strategy.");
-                getRecordsCache.shutdown();
-                LOG.debug("Record processor completed shutdown() for shard " + shardInfo.getShardId());
-            } catch (Exception e) {
-                applicationException = true;
-                throw e;
-            } finally {
-                MetricsHelper.addLatency(RECORD_PROCESSOR_SHUTDOWN_METRIC, recordProcessorStartTimeMillis,
-                        MetricsLevel.SUMMARY);
-            }
-
-            if (reason == ShutdownReason.TERMINATE) {
-                LOG.debug("Looking for child shards of shard " + shardInfo.getShardId());
-                // create leases for the child shards
-                ShardSyncer.checkAndCreateLeasesForNewShards(kinesisProxy,
-                        leaseManager,
-                        initialPositionInStream,
-                        cleanupLeasesOfCompletedShards,
-                        ignoreUnexpectedChildShards);
-                LOG.debug("Finished checking for child shards of shard " + shardInfo.getShardId());
-            }
-
-            return new TaskResult(null);
-        } catch (Exception e) {
-            if (applicationException) {
-                LOG.error("Application exception. ", e);
-            } else {
-                LOG.error("Caught exception: ", e);
-            }
-            exception = e;
-            // backoff if we encounter an exception.
-            try {
-                Thread.sleep(this.backoffTimeMillis);
-            } catch (InterruptedException ie) {
-                LOG.debug("Interrupted sleep", ie);
-            }
-        }
-
-        return new TaskResult(exception);
-    }
-
-    /*
-     * (non-Javadoc)
-     * 
-     * @see com.amazonaws.services.kinesis.clientlibrary.lib.worker.ITask#getTaskType()
-     */
-    @Override
-    public TaskType getTaskType() {
-        return taskType;
-    }
-
-    @VisibleForTesting
-    ShutdownReason getReason() {
-        return reason;
-    }
-
-}
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/SimpleRecordsFetcherFactory.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/SimpleRecordsFetcherFactory.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/StreamConfig.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/StreamConfig.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -19,7 +19,7 @@ import com.amazonaws.services.kinesis.clientlibrary.proxies.IKinesisProxy;
 /**
 * Used to capture stream configuration and pass it along.
 */
-class StreamConfig {
+public class StreamConfig {

    private final IKinesisProxy streamProxy;
    private final int maxRecords;
@ -54,7 +54,7 @@ class StreamConfig {
    /**
     * @return the streamProxy
     */
-    IKinesisProxy getStreamProxy() {
+    public IKinesisProxy getStreamProxy() {
        return streamProxy;
    }

@ -82,14 +82,14 @@ class StreamConfig {
    /**
     * @return the initialPositionInStream
     */
-    InitialPositionInStreamExtended getInitialPositionInStream() {
+    public InitialPositionInStreamExtended getInitialPositionInStream() {
        return initialPositionInStream;
    }

    /**
     * @return validateSequenceNumberBeforeCheckpointing
     */
-    boolean shouldValidateSequenceNumberBeforeCheckpointing() {
+    public boolean shouldValidateSequenceNumberBeforeCheckpointing() {
        return validateSequenceNumberBeforeCheckpointing;
    }
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/SynchronousGetRecordsRetrievalStrategy.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/SynchronousGetRecordsRetrievalStrategy.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -24,7 +24,7 @@ import lombok.NonNull;
@Data
 public class SynchronousGetRecordsRetrievalStrategy implements GetRecordsRetrievalStrategy {
    @NonNull
-    private final KinesisDataFetcher dataFetcher;
+    private final IDataFetcher dataFetcher;

    @Override
    public GetRecordsResult getRecords(final int maxRecords) {
@ -44,7 +44,7 @@ public class SynchronousGetRecordsRetrievalStrategy implements GetRecordsRetriev
    }
    
    @Override
-    public KinesisDataFetcher getDataFetcher() {
+    public IDataFetcher getDataFetcher() {
        return dataFetcher;
    }
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/TaskResult.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/TaskResult.java
@ -1,24 +1,28 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

+import com.amazonaws.services.kinesis.model.ChildShard;
+
+import java.util.List;
+
 /**
 * Used to capture information from a task that we want to communicate back to the higher layer.
 * E.g. exception thrown when executing the task, if we reach end of a shard.
 */
-class TaskResult {
+public class TaskResult {

    // Did we reach the end of the shard while processing this task.
    private boolean shardEndReached;
@ -26,13 +30,23 @@ class TaskResult {
    // Any exception caught while executing the task.
    private Exception exception;

+    // List of childShards of the current shard. This field is only required for the task result when we reach end of a shard.
+    private List<ChildShard> childShards;
+
+    private boolean leaseNotFound;
+
    /**
     * @return the shardEndReached
     */
-    protected boolean isShardEndReached() {
+    public boolean isShardEndReached() {
        return shardEndReached;
    }

+    /**
+     * @return the list of childShards.
+     */
+    protected List<ChildShard> getChildShards() { return childShards; }
+
    /**
     * @param shardEndReached the shardEndReached to set
     */
@ -40,6 +54,19 @@ class TaskResult {
        this.shardEndReached = shardEndReached;
    }

+    /**
+     * @param childShards the list of childShards to set
+     */
+    protected void setChildShards(List<ChildShard> childShards) { this.childShards = childShards; }
+
+    public boolean isLeaseNotFound() {
+        return leaseNotFound;
+    }
+
+    public void leaseNotFound() {
+        this.leaseNotFound = true;
+    }
+
    /**
     * @return the exception
     */
@ -50,7 +77,7 @@ class TaskResult {
    /**
     * @param e Any exception encountered when running the process task.
     */
-    TaskResult(Exception e) {
+    public TaskResult(Exception e) {
        this(e, false);
    }

@ -70,4 +97,10 @@ class TaskResult {
        this.shardEndReached = isShardEndReached;
    }

+    TaskResult(Exception e, boolean isShardEndReached, List<ChildShard> childShards) {
+        this.exception = e;
+        this.shardEndReached = isShardEndReached;
+        this.childShards = childShards;
+    }
+
 }
--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/TaskType.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/TaskType.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ThrottlingReporter.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/ThrottlingReporter.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/V1ToV2RecordProcessorAdapter.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/V1ToV2RecordProcessorAdapter.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/V1ToV2RecordProcessorFactoryAdapter.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/V1ToV2RecordProcessorFactoryAdapter.java
@ -1,16 +1,16 @@
 /*
- * Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- * Licensed under the Amazon Software License (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- * http://aws.amazon.com/asl/
- *
- * or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

--- a/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/Worker.java
+++ b/src/main/java/com/amazonaws/services/kinesis/clientlibrary/lib/worker/Worker.java
@ -1,16 +1,16 @@
 /*
- *  Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2019 Amazon.com, Inc. or its affiliates.
+ * Licensed 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
 *
- *  Licensed under the Amazon Software License (the "License").
- *  You may not use this file except in compliance with the License.
- *  A copy of the License is located at
+ *     http://www.apache.org/licenses/LICENSE-2.0
 *
- *  http://aws.amazon.com/asl/
- *
- *  or in the "license" file accompanying this file. This file 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.
+ * 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 com.amazonaws.services.kinesis.clientlibrary.lib.worker;

@ -25,19 +25,31 @@ import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Consumer;

-import org.apache.commons.lang.StringUtils;
+import com.amazonaws.services.kinesis.leases.exceptions.DependencyException;
+import com.amazonaws.services.kinesis.leases.exceptions.InvalidStateException;
+import com.amazonaws.services.kinesis.leases.exceptions.ProvisionedThroughputException;
+import com.amazonaws.services.kinesis.leases.impl.GenericLeaseSelector;
+import com.amazonaws.services.kinesis.leases.impl.LeaseCleanupManager;
+import com.amazonaws.services.kinesis.leases.impl.LeaseCoordinator;
+import com.amazonaws.services.kinesis.leases.impl.LeaseRenewer;
+import com.amazonaws.services.kinesis.leases.impl.LeaseTaker;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseRenewer;
+import com.amazonaws.services.kinesis.leases.interfaces.ILeaseTaker;
+import com.amazonaws.services.kinesis.leases.interfaces.LeaseSelector;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

-import com.amazonaws.AmazonWebServiceClient;
 import com.amazonaws.ClientConfiguration;
 import com.amazonaws.auth.AWSCredentialsProvider;
 import com.amazonaws.client.builder.AwsClientBuilder;
@ -69,7 +81,6 @@ import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;

-import lombok.NonNull;
 import lombok.Setter;
 import lombok.experimental.Accessors;

@ -82,8 +93,16 @@ public class Worker implements Runnable {

    private static final Log LOG = LogFactory.getLog(Worker.class);

-    private static final int MAX_INITIALIZATION_ATTEMPTS = 20;
+    // Default configs for periodic shard sync
+    private static final int SHARD_SYNC_SLEEP_FOR_PERIODIC_SHARD_SYNC = 0;
+    private static final int PERIODIC_SHARD_SYNC_MAX_WORKERS_DEFAULT = 1; //Default for KCL.
+    static long LEASE_TABLE_CHECK_FREQUENCY_MILLIS = 3 * 1000L;
+    static long MIN_WAIT_TIME_FOR_LEASE_TABLE_CHECK_MILLIS = 1 * 1000L;
+    static long MAX_WAIT_TIME_FOR_LEASE_TABLE_CHECK_MILLIS = 30 * 1000L;
+
    private static final WorkerStateChangeListener DEFAULT_WORKER_STATE_CHANGE_LISTENER = new NoOpWorkerStateChangeListener();
+    private static final LeaseCleanupValidator DEFAULT_LEASE_CLEANUP_VALIDATOR = new KinesisLeaseCleanupValidator();
+    private static final LeaseSelector<KinesisClientLease> DEFAULT_LEASE_SELECTOR = new GenericLeaseSelector<KinesisClientLease>();

    private WorkerLog wlog = new WorkerLog();

@ -107,17 +126,18 @@ public class Worker implements Runnable {
    private final Optional<Integer> maxGetRecordsThreadPool;

    private final KinesisClientLibLeaseCoordinator leaseCoordinator;
-    private final ShardSyncTaskManager controlServer;
+    private final ShardSyncTaskManager shardSyncTaskManager;

    private final ShardPrioritization shardPrioritization;

    private volatile boolean shutdown;
    private volatile long shutdownStartTimeMillis;
    private volatile boolean shutdownComplete = false;
+    private final ShardSyncer shardSyncer;

    // Holds consumers for shards the worker is currently tracking. Key is shard
    // info, value is ShardConsumer.
-    private ConcurrentMap<ShardInfo, ShardConsumer> shardInfoShardConsumerMap = new ConcurrentHashMap<ShardInfo, ShardConsumer>();
+    private ConcurrentMap<ShardInfo, IShardConsumer> shardInfoShardConsumerMap = new ConcurrentHashMap<ShardInfo, IShardConsumer>();
    private final boolean cleanupLeasesUponShardCompletion;

    private final boolean skipShardSyncAtWorkerInitializationIfLeasesExist;
@ -133,6 +153,16 @@ public class Worker implements Runnable {

    private WorkerStateChangeListener workerStateChangeListener;

+    // Periodic Shard Sync related fields
+    private LeaderDecider leaderDecider;
+    private ShardSyncStrategy shardSyncStrategy;
+    private IPeriodicShardSyncManager leaderElectedPeriodicShardSyncManager;
+
+    private final LeaseCleanupManager leaseCleanupManager;
+
+    // Shard Consumer Factory
+    private IShardConsumerFactory shardConsumerFactory;
+
    /**
     * Constructor.
     *
@ -377,26 +407,12 @@ public class Worker implements Runnable {
            KinesisClientLibConfiguration config, AmazonKinesis kinesisClient, AmazonDynamoDB dynamoDBClient,
            IMetricsFactory metricsFactory, ExecutorService execService) {
        this(config.getApplicationName(), new V1ToV2RecordProcessorFactoryAdapter(recordProcessorFactory),
-                config,
-                new StreamConfig(
-                        new KinesisProxy(config, kinesisClient),
-                        config.getMaxRecords(), config.getIdleTimeBetweenReadsInMillis(),
-                        config.shouldCallProcessRecordsEvenForEmptyRecordList(),
-                        config.shouldValidateSequenceNumberBeforeCheckpointing(),
-                        config.getInitialPositionInStreamExtended()),
+                config, getStreamConfig(config, kinesisClient),
                config.getInitialPositionInStreamExtended(), config.getParentShardPollIntervalMillis(),
                config.getShardSyncIntervalMillis(), config.shouldCleanupLeasesUponShardCompletion(), null,
-                new KinesisClientLibLeaseCoordinator(
-                        new KinesisClientLeaseManager(config.getTableName(), dynamoDBClient),
-                        config.getWorkerIdentifier(),
-                        config.getFailoverTimeMillis(),
-                        config.getEpsilonMillis(),
-                        config.getMaxLeasesForWorker(),
-                        config.getMaxLeasesToStealAtOneTime(),
-                        config.getMaxLeaseRenewalThreads(),
-                        metricsFactory)
-                    .withInitialLeaseTableReadCapacity(config.getInitialLeaseTableReadCapacity())
-                    .withInitialLeaseTableWriteCapacity(config.getInitialLeaseTableWriteCapacity()),
+                getLeaseCoordinator(config, dynamoDBClient, metricsFactory)
+                        .withInitialLeaseTableReadCapacity(config.getInitialLeaseTableReadCapacity())
+                        .withInitialLeaseTableWriteCapacity(config.getInitialLeaseTableWriteCapacity()),
                execService,
                metricsFactory,
                config.getTaskBackoffTimeMillis(),
@ -405,7 +421,7 @@ public class Worker implements Runnable {
                config.getShardPrioritizationStrategy(),
                config.getRetryGetRecordsInSeconds(),
                config.getMaxGetRecordsThreadPool(),
-                DEFAULT_WORKER_STATE_CHANGE_LISTENER);
+                DEFAULT_WORKER_STATE_CHANGE_LISTENER, DEFAULT_LEASE_CLEANUP_VALIDATOR, null, null);

        // If a region name was explicitly specified, use it as the region for Amazon Kinesis and Amazon DynamoDB.
        if (config.getRegionName() != null) {
@ -457,7 +473,7 @@ public class Worker implements Runnable {
    // NOTE: This has package level access solely for testing
    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 10 LINES
    Worker(String applicationName, IRecordProcessorFactory recordProcessorFactory, KinesisClientLibConfiguration config,
-           StreamConfig streamConfig, InitialPositionInStreamExtended initialPositionInStream, long parentShardPollIntervalMillis,
+            StreamConfig streamConfig, InitialPositionInStreamExtended initialPositionInStream, long parentShardPollIntervalMillis,
            long shardSyncIdleTimeMillis, boolean cleanupLeasesUponShardCompletion, ICheckpoint checkpoint,
            KinesisClientLibLeaseCoordinator leaseCoordinator, ExecutorService execService,
            IMetricsFactory metricsFactory, long taskBackoffTimeMillis, long failoverTimeMillis,
@ -465,7 +481,8 @@ public class Worker implements Runnable {
        this(applicationName, recordProcessorFactory, config, streamConfig, initialPositionInStream, parentShardPollIntervalMillis,
                shardSyncIdleTimeMillis, cleanupLeasesUponShardCompletion, checkpoint, leaseCoordinator, execService,
                metricsFactory, taskBackoffTimeMillis, failoverTimeMillis, skipShardSyncAtWorkerInitializationIfLeasesExist,
-                shardPrioritization, Optional.empty(), Optional.empty(), DEFAULT_WORKER_STATE_CHANGE_LISTENER);
+                shardPrioritization, Optional.empty(), Optional.empty(), DEFAULT_WORKER_STATE_CHANGE_LISTENER,
+                DEFAULT_LEASE_CLEANUP_VALIDATOR, null, null);
    }

    /**
@ -503,16 +520,40 @@ public class Worker implements Runnable {
     *            Time in seconds to wait before the worker retries to get a record.
     * @param maxGetRecordsThreadPool
     *            Max number of threads in the getRecords thread pool.
+     * @param leaseCleanupValidator
+     *            leaseCleanupValidator instance used to validate leases
+     * @param leaderDecider
+     *            leaderDecider instance used elect shard sync leaders
+     * @param periodicShardSyncManager
+     *            manages periodic shard sync tasks
     */
    // NOTE: This has package level access solely for testing
    // CHECKSTYLE:IGNORE ParameterNumber FOR NEXT 10 LINES
    Worker(String applicationName, IRecordProcessorFactory recordProcessorFactory, KinesisClientLibConfiguration config, StreamConfig streamConfig,
-           InitialPositionInStreamExtended initialPositionInStream, long parentShardPollIntervalMillis,
-           long shardSyncIdleTimeMillis, boolean cleanupLeasesUponShardCompletion, ICheckpoint checkpoint,
-           KinesisClientLibLeaseCoordinator leaseCoordinator, ExecutorService execService,
-           IMetricsFactory metricsFactory, long taskBackoffTimeMillis, long failoverTimeMillis,
-           boolean skipShardSyncAtWorkerInitializationIfLeasesExist, ShardPrioritization shardPrioritization,
-           Optional<Integer> retryGetRecordsInSeconds, Optional<Integer> maxGetRecordsThreadPool, WorkerStateChangeListener workerStateChangeListener) {
+            InitialPositionInStreamExtended initialPositionInStream, long parentShardPollIntervalMillis,
+            long shardSyncIdleTimeMillis, boolean cleanupLeasesUponShardCompletion, ICheckpoint checkpoint,
+            KinesisClientLibLeaseCoordinator leaseCoordinator, ExecutorService execService,
+            IMetricsFactory metricsFactory, long taskBackoffTimeMillis, long failoverTimeMillis,
+            boolean skipShardSyncAtWorkerInitializationIfLeasesExist, ShardPrioritization shardPrioritization,
+            Optional<Integer> retryGetRecordsInSeconds, Optional<Integer> maxGetRecordsThreadPool, WorkerStateChangeListener workerStateChangeListener,
+            LeaseCleanupValidator leaseCleanupValidator, LeaderDecider leaderDecider, IPeriodicShardSyncManager periodicShardSyncManager) {
+        this(applicationName, recordProcessorFactory, config, streamConfig, initialPositionInStream,
+                parentShardPollIntervalMillis, shardSyncIdleTimeMillis, cleanupLeasesUponShardCompletion, checkpoint,
+                leaseCoordinator, execService, metricsFactory, taskBackoffTimeMillis, failoverTimeMillis,
+                skipShardSyncAtWorkerInitializationIfLeasesExist, shardPrioritization, retryGetRecordsInSeconds,
+                maxGetRecordsThreadPool, workerStateChangeListener, new KinesisShardSyncer(leaseCleanupValidator),
+                leaderDecider, periodicShardSyncManager, null /*ShardConsumerFactory*/);
+    }
+
+    Worker(String applicationName, IRecordProcessorFactory recordProcessorFactory, KinesisClientLibConfiguration config,
+            StreamConfig streamConfig, InitialPositionInStreamExtended initialPositionInStream,
+            long parentShardPollIntervalMillis, long shardSyncIdleTimeMillis, boolean cleanupLeasesUponShardCompletion,
+            ICheckpoint checkpoint, KinesisClientLibLeaseCoordinator leaseCoordinator, ExecutorService execService,
+            IMetricsFactory metricsFactory, long taskBackoffTimeMillis, long failoverTimeMillis,
+            boolean skipShardSyncAtWorkerInitializationIfLeasesExist, ShardPrioritization shardPrioritization,
+            Optional<Integer> retryGetRecordsInSeconds, Optional<Integer> maxGetRecordsThreadPool,
+            WorkerStateChangeListener workerStateChangeListener, ShardSyncer shardSyncer, LeaderDecider leaderDecider,
+            IPeriodicShardSyncManager periodicShardSyncManager, IShardConsumerFactory shardConsumerFactory) {
        this.applicationName = applicationName;
        this.recordProcessorFactory = recordProcessorFactory;
        this.config = config;
@ -525,9 +566,10 @@ public class Worker implements Runnable {
        this.executorService = execService;
        this.leaseCoordinator = leaseCoordinator;
        this.metricsFactory = metricsFactory;
-        this.controlServer = new ShardSyncTaskManager(streamConfig.getStreamProxy(), leaseCoordinator.getLeaseManager(),
+        this.shardSyncer = shardSyncer;
+        this.shardSyncTaskManager = new ShardSyncTaskManager(streamConfig.getStreamProxy(), leaseCoordinator.getLeaseManager(),
                initialPositionInStream, cleanupLeasesUponShardCompletion, config.shouldIgnoreUnexpectedChildShards(),
-                shardSyncIdleTimeMillis, metricsFactory, executorService);
+                shardSyncIdleTimeMillis, metricsFactory, executorService, shardSyncer);
        this.taskBackoffTimeMillis = taskBackoffTimeMillis;
        this.failoverTimeMillis = failoverTimeMillis;
        this.skipShardSyncAtWorkerInitializationIfLeasesExist = skipShardSyncAtWorkerInitializationIfLeasesExist;
@ -536,6 +578,58 @@ public class Worker implements Runnable {
        this.maxGetRecordsThreadPool = maxGetRecordsThreadPool;
        this.workerStateChangeListener = workerStateChangeListener;
        workerStateChangeListener.onWorkerStateChange(WorkerStateChangeListener.WorkerState.CREATED);
+        createShardSyncStrategy(config.getShardSyncStrategyType(), leaderDecider, periodicShardSyncManager);
+        this.leaseCleanupManager = LeaseCleanupManager.newInstance(streamConfig.getStreamProxy(), leaseCoordinator.getLeaseManager(),
+                Executors.newSingleThreadScheduledExecutor(), metricsFactory, cleanupLeasesUponShardCompletion,
+                config.leaseCleanupIntervalMillis(), config.completedLeaseCleanupThresholdMillis(),
+                config.garbageLeaseCleanupThresholdMillis(), config.getMaxRecords());
+        this.shardConsumerFactory = shardConsumerFactory;
+    }
+
+    /**
+     * Create shard sync strategy and corresponding {@link LeaderDecider} based on provided configs. PERIODIC
+     * {@link ShardSyncStrategyType} honors custom leaderDeciders for leader election strategy, and does not permit
+     * skipping shard syncs if the hash range is complete. All other {@link ShardSyncStrategyType}s permit only a
+     * default single-leader strategy, and will skip shard syncs unless a hole in the hash range is detected.
+     */
+    private void createShardSyncStrategy(ShardSyncStrategyType strategyType,
+                                         LeaderDecider leaderDecider,
+                                         IPeriodicShardSyncManager periodicShardSyncManager) {
+        switch (strategyType) {
+            case PERIODIC:
+                this.leaderDecider = getOrCreateLeaderDecider(leaderDecider);
+                this.leaderElectedPeriodicShardSyncManager =
+                        getOrCreatePeriodicShardSyncManager(periodicShardSyncManager, false);
+                this.shardSyncStrategy = createPeriodicShardSyncStrategy();
+                break;
+            case SHARD_END:
+            default:
+                if (leaderDecider != null) {
+                    LOG.warn("LeaderDecider cannot be customized with non-PERIODIC shard sync strategy type. Using " +
+                             "default LeaderDecider.");
+                }
+                this.leaderDecider = getOrCreateLeaderDecider(null);
+                this.leaderElectedPeriodicShardSyncManager =
+                        getOrCreatePeriodicShardSyncManager(periodicShardSyncManager, true);
+                this.shardSyncStrategy = createShardEndShardSyncStrategy();
+        }
+
+        LOG.info("Shard sync strategy determined as " + shardSyncStrategy.getStrategyType().toString());
+    }
+
+    private static KinesisClientLibLeaseCoordinator getLeaseCoordinator(KinesisClientLibConfiguration config,
+            AmazonDynamoDB dynamoDBClient, IMetricsFactory metricsFactory) {
+        return new KinesisClientLibLeaseCoordinator(
+                new KinesisClientLeaseManager(config.getTableName(), dynamoDBClient, config.getBillingMode()), DEFAULT_LEASE_SELECTOR,
+                config.getWorkerIdentifier(), config.getFailoverTimeMillis(), config.getEpsilonMillis(),
+                config.getMaxLeasesForWorker(), config.getMaxLeasesToStealAtOneTime(),
+                config.getMaxLeaseRenewalThreads(), metricsFactory);
+    }
+
+    private static StreamConfig getStreamConfig(KinesisClientLibConfiguration config, AmazonKinesis kinesisClient) {
+        return new StreamConfig(new KinesisProxy(config, kinesisClient), config.getMaxRecords(),
+                config.getIdleTimeBetweenReadsInMillis(), config.shouldCallProcessRecordsEvenForEmptyRecordList(),
+                config.shouldValidateSequenceNumberBeforeCheckpointing(), config.getInitialPositionInStreamExtended());
    }

    /**
@ -552,6 +646,20 @@ public class Worker implements Runnable {
        return leaseCoordinator;
    }

+    /**
+     * @return the leaderDecider
+     */
+    LeaderDecider getLeaderDecider() {
+        return leaderDecider;
+    }
+
+    /**
+     * @return the leaderElectedPeriodicShardSyncManager
+     */
+    IPeriodicShardSyncManager getPeriodicShardSyncManager() {
+        return leaderElectedPeriodicShardSyncManager;
+    }
+
    /**
     * Start consuming data from the stream, and pass it to the application record processors.
     */
@ -564,7 +672,8 @@ public class Worker implements Runnable {
            initialize();
            LOG.info("Initialization complete. Starting worker loop.");
        } catch (RuntimeException e1) {
-            LOG.error("Unable to initialize after " + MAX_INITIALIZATION_ATTEMPTS + " attempts. Shutting down.", e1);
+            LOG.error("Unable to initialize after " + config.getMaxInitializationAttempts() + " attempts. " +
+                    "Shutting down.", e1);
            shutdown();
        }

@ -582,7 +691,7 @@ public class Worker implements Runnable {
            boolean foundCompletedShard = false;
            Set<ShardInfo> assignedShards = new HashSet<>();
            for (ShardInfo shardInfo : getShardInfoForAssignments()) {
-                ShardConsumer shardConsumer = createOrGetShardConsumer(shardInfo, recordProcessorFactory);
+                IShardConsumer shardConsumer = createOrGetShardConsumer(shardInfo, recordProcessorFactory);
                if (shardConsumer.isShutdown() && shardConsumer.getShutdownReason().equals(ShutdownReason.TERMINATE)) {
                    foundCompletedShard = true;
                } else {
@ -591,10 +700,6 @@ public class Worker implements Runnable {
                assignedShards.add(shardInfo);
            }

-            if (foundCompletedShard) {
-                controlServer.syncShardAndLeaseInfo(null);
-            }
-
            // clean up shard consumers for unassigned shards
            cleanupShardConsumers(assignedShards);

@ -617,35 +722,38 @@ public class Worker implements Runnable {
        boolean isDone = false;
        Exception lastException = null;

-        for (int i = 0; (!isDone) && (i < MAX_INITIALIZATION_ATTEMPTS); i++) {
+        for (int i = 0; (!isDone) && (i < config.getMaxInitializationAttempts()); i++) {
            try {
                LOG.info("Initialization attempt " + (i + 1));
                LOG.info("Initializing LeaseCoordinator");
                leaseCoordinator.initialize();

-                TaskResult result = null;
-                if (!skipShardSyncAtWorkerInitializationIfLeasesExist
-                        || leaseCoordinator.getLeaseManager().isLeaseTableEmpty()) {
-                    LOG.info("Syncing Kinesis shard info");
-                    ShardSyncTask shardSyncTask = new ShardSyncTask(streamConfig.getStreamProxy(),
-                            leaseCoordinator.getLeaseManager(), initialPosition, cleanupLeasesUponShardCompletion,
-                            config.shouldIgnoreUnexpectedChildShards(), 0L);
-                    result = new MetricsCollectingTaskDecorator(shardSyncTask, metricsFactory).call();
-                } else {
-                    LOG.info("Skipping shard sync per config setting (and lease table is not empty)");
+                // Perform initial lease sync if configs allow it, with jitter.
+                if (shouldInitiateLeaseSync()) {
+                    LOG.info(config.getWorkerIdentifier() + " worker is beginning initial lease sync.");
+                    TaskResult result = leaderElectedPeriodicShardSyncManager.syncShardsOnce();
+                    if (result.getException() != null) {
+                        throw result.getException();
+                    }
                }

-                if (result == null || result.getException() == null) {
-                    if (!leaseCoordinator.isRunning()) {
-                        LOG.info("Starting LeaseCoordinator");
-                        leaseCoordinator.start();
-                    } else {
-                        LOG.info("LeaseCoordinator is already running. No need to start it.");
-                    }
-                    isDone = true;
+                leaseCleanupManager.start();
+
+                // If we reach this point, then we either skipped the lease sync or did not have any exception for the
+                // shard sync in the previous attempt.
+                if (!leaseCoordinator.isRunning()) {
+                    LOG.info("Starting LeaseCoordinator");
+                    leaseCoordinator.start();
                } else {
-                    lastException = result.getException();
+                    LOG.info("LeaseCoordinator is already running. No need to start it.");
                }
+
+                // All shard sync strategies' initialization handlers should begin a periodic shard sync. For
+                // PeriodicShardSync strategy, this is the main shard sync loop. For ShardEndShardSync and other
+                // shard sync strategies, this serves as an auditor background process.
+                shardSyncStrategy.onWorkerInitialization();
+                isDone = true;
+
            } catch (LeasingException e) {
                LOG.error("Caught exception when initializing LeaseCoordinator", e);
                lastException = e;
@ -661,11 +769,39 @@ public class Worker implements Runnable {
        }

        if (!isDone) {
+            leaderElectedPeriodicShardSyncManager.stop();
            throw new RuntimeException(lastException);
+
        }
        workerStateChangeListener.onWorkerStateChange(WorkerStateChangeListener.WorkerState.STARTED);
    }

+    @VisibleForTesting
+    boolean shouldInitiateLeaseSync() throws InterruptedException, DependencyException, InvalidStateException,
+            ProvisionedThroughputException {
+
+        final ILeaseManager leaseManager = leaseCoordinator.getLeaseManager();
+        if (skipShardSyncAtWorkerInitializationIfLeasesExist && !leaseManager.isLeaseTableEmpty()) {
+            LOG.info("Skipping shard sync because getSkipShardSyncAtWorkerInitializationIfLeasesExist config is set " +
+                    "to TRUE and lease table is not empty.");
+            return false;
+        }
+
+        final long waitTime = ThreadLocalRandom.current().nextLong(MIN_WAIT_TIME_FOR_LEASE_TABLE_CHECK_MILLIS,
+                MAX_WAIT_TIME_FOR_LEASE_TABLE_CHECK_MILLIS);
+        final long waitUntil = System.currentTimeMillis() + waitTime;
+
+        boolean shouldInitiateLeaseSync = true;
+        while (System.currentTimeMillis() < waitUntil && (shouldInitiateLeaseSync = leaseManager.isLeaseTableEmpty())) {
+            // Check every 3 seconds if lease table is still empty, to minimize contention between all workers
+            // bootstrapping from empty lease table at the same time.
+            LOG.info("Lease table is still empty. Checking again in " + LEASE_TABLE_CHECK_FREQUENCY_MILLIS + " ms.");
+            Thread.sleep(LEASE_TABLE_CHECK_FREQUENCY_MILLIS);
+        }
+
+        return shouldInitiateLeaseSync;
+    }
+
    /**
     * NOTE: This method is internal/private to the Worker class. It has package access solely for testing.
     *
@ -851,17 +987,20 @@ public class Worker implements Runnable {
                ShutdownNotification shutdownNotification = new ShardConsumerShutdownNotification(leaseCoordinator,
                        lease, notificationCompleteLatch, shutdownCompleteLatch);
                ShardInfo shardInfo = KinesisClientLibLeaseCoordinator.convertLeaseToAssignment(lease);
-                ShardConsumer consumer = shardInfoShardConsumerMap.get(shardInfo);
-                if (consumer != null) {
-                    consumer.notifyShutdownRequested(shutdownNotification);
-                } else {
+                IShardConsumer consumer = shardInfoShardConsumerMap.get(shardInfo);
+
+                if (consumer == null || KinesisConsumerStates.ShardConsumerState.SHUTDOWN_COMPLETE.equals(consumer.getCurrentState())) {
                    //
-                    // There is a race condition between retrieving the current assignments, and creating the
+                    // CASE1: There is a race condition between retrieving the current assignments, and creating the
                    // notification. If the a lease is lost in between these two points, we explicitly decrement the
                    // notification latches to clear the shutdown.
                    //
+                    // CASE2: The shard consumer is in SHUTDOWN_COMPLETE state and will not decrement the latches by itself.
+                    //
                    notificationCompleteLatch.countDown();
                    shutdownCompleteLatch.countDown();
+                } else {
+                    consumer.notifyShutdownRequested(shutdownNotification);
                }
            }
            return new GracefulShutdownContext(shutdownCompleteLatch, notificationCompleteLatch, this);
@ -872,7 +1011,7 @@ public class Worker implements Runnable {
        return shutdownComplete;
    }

-    ConcurrentMap<ShardInfo, ShardConsumer> getShardInfoShardConsumerMap() {
+    ConcurrentMap<ShardInfo, IShardConsumer> getShardInfoShardConsumerMap() {
        return shardInfoShardConsumerMap;
    }

@ -888,7 +1027,7 @@ public class Worker implements Runnable {
     * the worker itself.
     * <ol>
     * <li>Call to start shutdown invoked</li>
-     * <li>Lease coordinator told to stop taking leases, and to drop existing leases.</li>
+     * <li>Lease coordinator told to onWorkerShutDown taking leases, and to drop existing leases.</li>
     * <li>Worker discovers record processors that no longer have leases.</li>
     * <li>Worker triggers shutdown with state {@link ShutdownReason#ZOMBIE}.</li>
     * <li>Once all record processors are shutdown, worker terminates owned resources.</li>
@ -910,6 +1049,14 @@ public class Worker implements Runnable {
        // Lost leases will force Worker to begin shutdown process for all shard consumers in
        // Worker.run().
        leaseCoordinator.stop();
+
+        // Stop the lease cleanup manager
+        leaseCleanupManager.shutdown();
+
+        // Stop the periodicShardSyncManager for the worker
+        if (shardSyncStrategy != null) {
+            shardSyncStrategy.onWorkerShutDown();
+        }
        workerStateChangeListener.onWorkerStateChange(WorkerStateChangeListener.WorkerState.SHUT_DOWN);
    }

@ -964,8 +1111,8 @@ public class Worker implements Runnable {
     *            RecordProcessor factory
     * @return ShardConsumer for the shard
     */
-    ShardConsumer createOrGetShardConsumer(ShardInfo shardInfo, IRecordProcessorFactory processorFactory) {
-        ShardConsumer consumer = shardInfoShardConsumerMap.get(shardInfo);
+    IShardConsumer createOrGetShardConsumer(ShardInfo shardInfo, IRecordProcessorFactory processorFactory) {
+        IShardConsumer consumer = shardInfoShardConsumerMap.get(shardInfo);
        // Instantiate a new consumer if we don't have one, or the one we
        // had was from an earlier
        // lease instance (and was shutdown). Don't need to create another
@ -980,14 +1127,26 @@ public class Worker implements Runnable {
        return consumer;
    }

-    protected ShardConsumer buildConsumer(ShardInfo shardInfo, IRecordProcessorFactory processorFactory) {
-        IRecordProcessor recordProcessor = processorFactory.createProcessor();
+    protected IShardConsumer buildConsumer(ShardInfo shardInfo, IRecordProcessorFactory processorFactory) {
+        final IRecordProcessor recordProcessor = processorFactory.createProcessor();
+        final RecordProcessorCheckpointer recordProcessorCheckpointer = new RecordProcessorCheckpointer(
+                shardInfo,
+                checkpointTracker,
+                new SequenceNumberValidator(
+                        streamConfig.getStreamProxy(),
+                        shardInfo.getShardId(),
+                        streamConfig.shouldValidateSequenceNumberBeforeCheckpointing()));

-        return new ShardConsumer(shardInfo,
+        if(shardConsumerFactory == null){ //Default to KinesisShardConsumerFactory if null
+            this.shardConsumerFactory = new KinesisShardConsumerFactory();
+        }
+
+        return shardConsumerFactory.createShardConsumer(shardInfo,
                streamConfig,
                checkpointTracker,
                recordProcessor,
-                leaseCoordinator.getLeaseManager(),
+                recordProcessorCheckpointer,
+                leaseCoordinator,
                parentShardPollIntervalMillis,
                cleanupLeasesUponShardCompletion,
                executorService,
@ -996,8 +1155,8 @@ public class Worker implements Runnable {
                skipShardSyncAtWorkerInitializationIfLeasesExist,
                retryGetRecordsInSeconds,
                maxGetRecordsThreadPool,
-                config);
-
+                config, shardSyncer, shardSyncStrategy,
+                leaseCleanupManager);
    }

    /**
@ -1047,7 +1206,7 @@ public class Worker implements Runnable {
        private void resetInfoLogging() {
            if (infoReporting) {
                // We just logged at INFO level for a pass through worker loop
-                if (LOG.isInfoEnabled()) {
+                if (!LOG.isDebugEnabled() && !LOG.isTraceEnabled()) {
                    infoReporting = false;
                    nextReportTime = System.currentTimeMillis() + reportIntervalMillis;
                } // else is DEBUG or TRACE so leave reporting true
@ -1071,8 +1230,8 @@ public class Worker implements Runnable {
     *            KinesisClientLibConfiguration
     * @return Returns metrics factory based on the config.
     */
-    private static IMetricsFactory getMetricsFactory(AmazonCloudWatch cloudWatchClient,
-            KinesisClientLibConfiguration config) {
+    public static IMetricsFactory getMetricsFactory(AmazonCloudWatch cloudWatchClient,
+                     KinesisClientLibConfiguration config) {
        IMetricsFactory metricsFactory;
        if (config.getMetricsLevel() == MetricsLevel.NONE) {
            metricsFactory = new NullMetricsFactory();
@ -1106,6 +1265,49 @@ public class Worker implements Runnable {
        }
    }

+    private PeriodicShardSyncStrategy createPeriodicShardSyncStrategy() {
+        return new PeriodicShardSyncStrategy(leaderElectedPeriodicShardSyncManager);
+    }
+
+    private ShardEndShardSyncStrategy createShardEndShardSyncStrategy() {
+        return new ShardEndShardSyncStrategy(shardSyncTaskManager, leaderElectedPeriodicShardSyncManager);
+    }
+
+    private LeaderDecider getOrCreateLeaderDecider(LeaderDecider leaderDecider) {
+        if (leaderDecider != null) {
+            return leaderDecider;
+        }
+
+        return new DeterministicShuffleShardSyncLeaderDecider(leaseCoordinator.getLeaseManager(),
+                Executors.newSingleThreadScheduledExecutor(), PERIODIC_SHARD_SYNC_MAX_WORKERS_DEFAULT);
+    }
+
+    /** A non-null PeriodicShardSyncManager can only provided from unit tests. Any application code will create the
+     * PeriodicShardSyncManager for the first time here. */
+    private IPeriodicShardSyncManager getOrCreatePeriodicShardSyncManager(IPeriodicShardSyncManager periodicShardSyncManager,
+                                                                         boolean isAuditorMode) {
+        if (periodicShardSyncManager != null) {
+            return periodicShardSyncManager;
+        }
+
+        return new KinesisPeriodicShardSyncManager(config.getWorkerIdentifier(),
+                                            leaderDecider,
+                                            new ShardSyncTask(streamConfig.getStreamProxy(),
+                                                    leaseCoordinator.getLeaseManager(),
+                                                    config.getInitialPositionInStreamExtended(),
+                                                    config.shouldCleanupLeasesUponShardCompletion(),
+                                                    config.shouldIgnoreUnexpectedChildShards(),
+                                                    SHARD_SYNC_SLEEP_FOR_PERIODIC_SHARD_SYNC,
+                                                    shardSyncer,
+                                                    null),
+                                            metricsFactory,
+                                            leaseCoordinator.getLeaseManager(),
+                                            streamConfig.getStreamProxy(),
+                                            isAuditorMode,
+                                            config.getLeasesRecoveryAuditorExecutionFrequencyMillis(),
+                                            config.getLeasesRecoveryAuditorInconsistencyConfidenceThreshold());
+    }
+
    /**
     * Extension to CWMetricsFactory, so worker can identify whether it owns the metrics factory instance or not.
     * Visible and non-final only for testing.
@ -1157,7 +1359,23 @@ public class Worker implements Runnable {
        @Setter @Accessors(fluent = true)
        private IKinesisProxy kinesisProxy;
        @Setter @Accessors(fluent = true)
+        private IPeriodicShardSyncManager periodicShardSyncManager;
+        @Setter @Accessors(fluent = true)
+        private IShardConsumerFactory shardConsumerFactory;
+        @Setter @Accessors(fluent = true)
        private WorkerStateChangeListener workerStateChangeListener;
+        @Setter @Accessors(fluent = true)
+        private LeaseCleanupValidator leaseCleanupValidator;
+        @Setter @Accessors(fluent = true)
+        private LeaseSelector<KinesisClientLease> leaseSelector;
+        @Setter @Accessors(fluent = true)
+        private LeaderDecider leaderDecider;
+        @Setter @Accessors(fluent = true)
+        private ILeaseTaker<KinesisClientLease> leaseTaker;
+        @Setter @Accessors(fluent = true)
+        private ILeaseRenewer<KinesisClientLease> leaseRenewer;
+        @Setter @Accessors(fluent = true)
+        private ShardSyncer shardSyncer;

        @VisibleForTesting
        AmazonKinesis getKinesisClient() {
@ -1213,6 +1431,16 @@ public class Worker implements Runnable {
                throw new IllegalArgumentException(
                        "Kinesis Client Library configuration needs to be provided to build Worker");
            }
+            if (periodicShardSyncManager != null) {
+                if (leaseManager == null || shardSyncer == null || metricsFactory == null || leaderDecider == null) {
+
+                    throw new IllegalArgumentException("LeaseManager, ShardSyncer, MetricsFactory, and LeaderDecider must be provided if PeriodicShardSyncManager is provided");
+                }
+            }
+            if(shardConsumerFactory == null){
+                shardConsumerFactory = new KinesisShardConsumerFactory();
+            }
+
            if (recordProcessorFactory == null) {
                throw new IllegalArgumentException("A Record Processor Factory needs to be provided to build Worker");
            }
@ -1255,15 +1483,19 @@ public class Worker implements Runnable {
            if (config.getKinesisEndpoint() != null) {
                setField(kinesisClient, "endpoint", kinesisClient::setEndpoint, config.getKinesisEndpoint());
            }
+
            if (metricsFactory == null) {
                metricsFactory = getMetricsFactory(cloudWatchClient, config);
            }
+
            if (leaseManager == null) {
-                leaseManager = new KinesisClientLeaseManager(config.getTableName(), dynamoDBClient);
+                leaseManager = new KinesisClientLeaseManager(config.getTableName(), dynamoDBClient, config.getBillingMode());
            }
+
            if (shardPrioritization == null) {
-                shardPrioritization = new ParentsFirstShardPrioritization(1);
+                shardPrioritization = new NoOpShardPrioritization();
            }
+
            if (kinesisProxy == null) {
                kinesisProxy = new KinesisProxy(config, kinesisClient);
            }
@ -1272,6 +1504,34 @@ public class Worker implements Runnable {
                workerStateChangeListener = DEFAULT_WORKER_STATE_CHANGE_LISTENER;
            }

+            if (leaseCleanupValidator == null) {
+                leaseCleanupValidator = DEFAULT_LEASE_CLEANUP_VALIDATOR;
+            }
+
+            if (shardSyncer == null) {
+                shardSyncer = new KinesisShardSyncer(leaseCleanupValidator);
+            }
+
+            if(leaseSelector == null) {
+                leaseSelector = DEFAULT_LEASE_SELECTOR;
+            }
+
+            if (leaseTaker == null) {
+                leaseTaker = new LeaseTaker<>(leaseManager, leaseSelector, config.getWorkerIdentifier(), config.getFailoverTimeMillis())
+                        .withMaxLeasesForWorker(config.getMaxLeasesForWorker())
+                        .withMaxLeasesToStealAtOneTime(config.getMaxLeasesToStealAtOneTime());
+            }
+
+            // We expect users to either inject both LeaseRenewer and the corresponding thread-pool, or neither of them (DEFAULT).
+            if (leaseRenewer == null) {
+                ExecutorService leaseRenewerThreadPool = LeaseCoordinator.getDefaultLeaseRenewalExecutorService(config.getMaxLeaseRenewalThreads());
+                leaseRenewer = new LeaseRenewer<>(leaseManager, config.getWorkerIdentifier(), config.getFailoverTimeMillis(), leaseRenewerThreadPool, metricsFactory);
+            }
+
+            if (leaderDecider == null) {
+                leaderDecider = new DeterministicShuffleShardSyncLeaderDecider(leaseManager,
+                    Executors.newSingleThreadScheduledExecutor(), PERIODIC_SHARD_SYNC_MAX_WORKERS_DEFAULT);
+            }
            return new Worker(config.getApplicationName(),
                    recordProcessorFactory,
                    config,
@ -1286,16 +1546,14 @@ public class Worker implements Runnable {
                    config.getShardSyncIntervalMillis(),
                    config.shouldCleanupLeasesUponShardCompletion(),
                    null,
-                    new KinesisClientLibLeaseCoordinator(leaseManager,
-                            config.getWorkerIdentifier(),
+                    new KinesisClientLibLeaseCoordinator(leaseManager, leaseTaker, leaseRenewer,
                            config.getFailoverTimeMillis(),
                            config.getEpsilonMillis(),
                            config.getMaxLeasesForWorker(),
                            config.getMaxLeasesToStealAtOneTime(),
-                            config.getMaxLeaseRenewalThreads(),
                            metricsFactory)
-                        .withInitialLeaseTableReadCapacity(config.getInitialLeaseTableReadCapacity())
-                        .withInitialLeaseTableWriteCapacity(config.getInitialLeaseTableWriteCapacity()),
+                            .withInitialLeaseTableReadCapacity(config.getInitialLeaseTableReadCapacity())
+                            .withInitialLeaseTableWriteCapacity(config.getInitialLeaseTableWriteCapacity()),
                    execService,
                    metricsFactory,
                    config.getTaskBackoffTimeMillis(),
@ -1304,14 +1562,18 @@ public class Worker implements Runnable {
                    shardPrioritization,
                    config.getRetryGetRecordsInSeconds(),
                    config.getMaxGetRecordsThreadPool(),
-                    workerStateChangeListener);
+                    workerStateChangeListener,
+                    shardSyncer,
+                    leaderDecider,
+                    periodicShardSyncManager /*PeriodicShardSyncManager*/,
+                    shardConsumerFactory);
        }

        <R, T extends AwsClientBuilder<T, R>> R createClient(final T builder,
-                                                             final AWSCredentialsProvider credentialsProvider,
-                                                             final ClientConfiguration clientConfiguration,
-                                                             final String endpointUrl,
-                                                             final String region) {
+                final AWSCredentialsProvider credentialsProvider,
+                final ClientConfiguration clientConfiguration,
+                final String endpointUrl,
+                final String region) {
            if (credentialsProvider != null) {
                builder.withCredentials(credentialsProvider);
            }
--- a/Show more
+++ b/Show more