diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Azure.Messaging.EventHubs.Processor.csproj b/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Azure.Messaging.EventHubs.Processor.csproj
index 96a398526e55..d8a53cc2e5cc 100644
--- a/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Azure.Messaging.EventHubs.Processor.csproj
+++ b/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Azure.Messaging.EventHubs.Processor.csproj
@@ -33,6 +33,7 @@
   <Import Project="$(MSBuildThisFileDirectory)..\..\Azure.Messaging.EventHubs.Shared\src\Azure.Messaging.EventHubs.Shared.Diagnostics.projitems" Label="Diagnostics" />
   <Import Project="$(MSBuildThisFileDirectory)..\..\Azure.Messaging.EventHubs.Shared\src\Azure.Messaging.EventHubs.Shared.Authorization.projitems" Label="Authorization" />
   <Import Project="$(MSBuildThisFileDirectory)..\..\Azure.Messaging.EventHubs.Shared\src\Azure.Messaging.EventHubs.Shared.Processor.projitems" Label="Processor" />
+  <Import Project="$(MSBuildThisFileDirectory)..\..\Azure.Messaging.EventHubs.Shared\src\Azure.Messaging.EventHubs.Shared.BlobCheckpointStore.projitems" Label="CheckpointStore" />
 
   <!-- Import Azure.Core shared source -->
   <ItemGroup>
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobsCheckpointStore.Diagnostics.cs b/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobsCheckpointStore.Diagnostics.cs
new file mode 100644
index 000000000000..43e3bcfada57
--- /dev/null
+++ b/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobsCheckpointStore.Diagnostics.cs
@@ -0,0 +1,227 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Azure.Messaging.EventHubs.Processor.Diagnostics;
+
+namespace Azure.Messaging.EventHubs.Processor
+{
+    /// <summary>
+    ///   A storage blob service that keeps track of checkpoints and ownership.
+    /// </summary>
+    ///
+    internal sealed partial class BlobsCheckpointStore
+    {
+        /// <summary>
+        /// Initializes the <see cref="BlobsCheckpointStore"/> type.
+        /// </summary>
+#pragma warning disable CA1810 // Initialize static fields inline
+        static BlobsCheckpointStore()
+        {
+            BlobsResourceDoesNotExist = Resources.BlobsResourceDoesNotExist;
+        }
+#pragma warning restore CA1810
+
+        /// <summary>
+        ///   The instance of <see cref="BlobEventStoreEventSource" /> which can be mocked for testing.
+        /// </summary>
+        ///
+        internal BlobEventStoreEventSource Logger { get; set; } = BlobEventStoreEventSource.Log;
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of ownership has completed.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        /// <param name="ownershipCount">The amount of ownership received from the storage service.</param>
+        ///
+        partial void ListOwnershipComplete(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, int ownershipCount) =>
+            Logger.ListOwnershipComplete(fullyQualifiedNamespace, eventHubName, consumerGroup, ownershipCount);
+
+        /// <summary>
+        ///   Indicates that an unhandled exception was encountered while retrieving a list of ownership.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void ListOwnershipError(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string errorMessage) =>
+            Logger.ListOwnershipError(fullyQualifiedNamespace, eventHubName, consumerGroup, errorMessage);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of ownership has started.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        ///
+        partial void ListOwnershipStart(string fullyQualifiedNamespace, string eventHubName, string consumerGroup) =>
+            Logger.ListOwnershipStart(fullyQualifiedNamespace, eventHubName, consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of checkpoints has completed.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoints are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoints are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoints are associated with.</param>
+        /// <param name="checkpointCount">The amount of checkpoints received from the storage service.</param>
+        ///
+        partial void ListCheckpointsComplete(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, int checkpointCount) =>
+            Logger.ListCheckpointsComplete(fullyQualifiedNamespace, eventHubName, consumerGroup, checkpointCount);
+
+        /// <summary>
+        ///   Indicates that an unhandled exception was encountered while retrieving a list of checkpoints.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoints are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoints are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void ListCheckpointsError(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string errorMessage) =>
+            Logger.ListCheckpointsError(fullyQualifiedNamespace, eventHubName, consumerGroup, errorMessage);
+
+        /// <summary>
+        ///   Indicates that invalid checkpoint data was found during an attempt to retrieve a list of checkpoints.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition the data is associated with.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the data is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the data is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the data is associated with.</param>
+        ///
+        partial void InvalidCheckpointFound(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup) =>
+            Logger.InvalidCheckpointFound(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of checkpoints has started.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoints are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoints are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoints are associated with.</param>
+        ///
+        partial void ListCheckpointsStart(string fullyQualifiedNamespace, string eventHubName, string consumerGroup) =>
+            Logger.ListCheckpointsStart(fullyQualifiedNamespace, eventHubName, consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an unhandled exception was encountered while updating a checkpoint.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being checkpointed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoint is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoint is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoint is associated with.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void UpdateCheckpointError(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string errorMessage) =>
+            Logger.UpdateCheckpointError(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup, errorMessage);
+
+        /// <summary>
+        ///   Indicates that an attempt to update a checkpoint has completed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being checkpointed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoint is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoint is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoint is associated with.</param>
+        ///
+        partial void UpdateCheckpointComplete(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup) =>
+            Logger.UpdateCheckpointComplete(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to create/update a checkpoint has started.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being checkpointed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoint is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoint is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoint is associated with.</param>
+        ///
+        partial void UpdateCheckpointStart(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup) =>
+            Logger.UpdateCheckpointStart(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve claim partition ownership has completed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        ///
+        partial void ClaimOwnershipComplete(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier) =>
+            Logger.ClaimOwnershipComplete(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup, ownerIdentifier);
+
+        /// <summary>
+        ///   Indicates that an exception was encountered while attempting to retrieve claim partition ownership.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void ClaimOwnershipError(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier, string errorMessage) =>
+            Logger.ClaimOwnershipError(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup, ownerIdentifier, errorMessage);
+
+        /// <summary>
+        ///   Indicates that ownership was unable to be claimed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        /// <param name="message">The message for the failure.</param>
+        ///
+        partial void OwnershipNotClaimable(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier, string message) =>
+            Logger.OwnershipNotClaimable(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup, ownerIdentifier, message);
+
+        /// <summary>
+        ///   Indicates that ownership was successfully claimed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        ///
+        partial void OwnershipClaimed(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier) =>
+            Logger.OwnershipClaimed(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup, ownerIdentifier);
+
+        /// <summary>
+        ///   Indicates that an attempt to claim a partition ownership has started.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        ///
+        partial void ClaimOwnershipStart(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier) =>
+            Logger.ClaimOwnershipStart(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup, ownerIdentifier);
+
+        /// <summary>
+        ///   Indicates that a <see cref="BlobsCheckpointStore" /> was created.
+        /// </summary>
+        ///
+        /// <param name="typeName">The type name for the checkpoint store.</param>
+        /// <param name="accountName">The Storage account name corresponding to the associated container client.</param>
+        /// <param name="containerName">The name of the associated container client.</param>
+        ///
+        partial void BlobsCheckpointStoreCreated(string typeName, string accountName, string containerName) =>
+            Logger.BlobsCheckpointStoreCreated(typeName, accountName, containerName);
+    }
+}
\ No newline at end of file
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Azure.Messaging.EventHubs.Shared.BlobCheckpointStore.projitems b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Azure.Messaging.EventHubs.Shared.BlobCheckpointStore.projitems
new file mode 100644
index 000000000000..b0b2915fb489
--- /dev/null
+++ b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Azure.Messaging.EventHubs.Shared.BlobCheckpointStore.projitems
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>826d9924-8c85-4db1-9407-1b133a3d953f</SharedGUID>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <Import_RootNamespace>Azure.Messaging.EventHubs.Primitives</Import_RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisfileDirectory)BlobCheckpointStore\*.cs" Link="SharedSource\BlobCheckpointStore\%(Filename)%(Extension)" />
+  </ItemGroup>
+</Project>
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobMetadataKey.cs b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/BlobCheckpointStore/BlobMetadataKey.cs
old mode 100755
new mode 100644
similarity index 100%
rename from sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobMetadataKey.cs
rename to sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/BlobCheckpointStore/BlobMetadataKey.cs
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobsCheckpointStore.cs b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/BlobCheckpointStore/BlobsCheckpointStore.cs
similarity index 56%
rename from sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobsCheckpointStore.cs
rename to sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/BlobCheckpointStore/BlobsCheckpointStore.cs
index ddfd7f6624f0..5e3ba844f960 100644
--- a/sdk/eventhub/Azure.Messaging.EventHubs.Processor/src/Storage/BlobsCheckpointStore.cs
+++ b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/BlobCheckpointStore/BlobsCheckpointStore.cs
@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
-using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,7 +12,6 @@
 using Azure.Messaging.EventHubs.Consumer;
 using Azure.Messaging.EventHubs.Core;
 using Azure.Messaging.EventHubs.Primitives;
-using Azure.Messaging.EventHubs.Processor.Diagnostics;
 using Azure.Storage.Blobs;
 using Azure.Storage.Blobs.Models;
 
@@ -23,8 +21,13 @@ namespace Azure.Messaging.EventHubs.Processor
     ///   A storage blob service that keeps track of checkpoints and ownership.
     /// </summary>
     ///
-    internal sealed class BlobsCheckpointStore : StorageManager
+    internal sealed partial class BlobsCheckpointStore : StorageManager
     {
+#pragma warning disable CA1802 // Use a constant field
+        /// <summary>A message to use when throwing exception when checkpoint container or blob does not exists.</summary>
+        private static readonly string BlobsResourceDoesNotExist = "The Azure Storage Blobs container or blob used by the Event Processor Client does not exist.";
+#pragma warning restore CA1810
+
         /// <summary>A regular expression used to capture strings enclosed in double quotes.</summary>
         private static readonly Regex DoubleQuotesExpression = new Regex("\"(.*)\"", RegexOptions.Compiled);
 
@@ -58,12 +61,6 @@ internal sealed class BlobsCheckpointStore : StorageManager
         ///
         private EventHubsRetryPolicy RetryPolicy { get; }
 
-        /// <summary>
-        ///   The instance of <see cref="BlobEventStoreEventSource" /> which can be mocked for testing.
-        /// </summary>
-        ///
-        internal BlobEventStoreEventSource Logger { get; set; } = BlobEventStoreEventSource.Log;
-
         /// <summary>
         ///   Initializes a new instance of the <see cref="BlobsCheckpointStore" /> class.
         /// </summary>
@@ -79,7 +76,7 @@ public BlobsCheckpointStore(BlobContainerClient blobContainerClient,
 
             ContainerClient = blobContainerClient;
             RetryPolicy = retryPolicy;
-            Logger.BlobsCheckpointStoreCreated(nameof(BlobsCheckpointStore), blobContainerClient.AccountName, blobContainerClient.Name);
+            BlobsCheckpointStoreCreated(nameof(BlobsCheckpointStore), blobContainerClient.AccountName, blobContainerClient.Name);
         }
 
         /// <summary>
@@ -99,7 +96,7 @@ public override async Task<IEnumerable<EventProcessorPartitionOwnership>> ListOw
                                                                                                      CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested<TaskCanceledException>();
-            Logger.ListOwnershipStart(fullyQualifiedNamespace, eventHubName, consumerGroup);
+            ListOwnershipStart(fullyQualifiedNamespace, eventHubName, consumerGroup);
 
             List<EventProcessorPartitionOwnership> result = null;
 
@@ -138,12 +135,12 @@ async Task<List<EventProcessorPartitionOwnership>> listOwnershipAsync(Cancellati
             }
             catch (RequestFailedException ex) when (ex.ErrorCode == BlobErrorCode.ContainerNotFound)
             {
-                Logger.ListOwnershipError(fullyQualifiedNamespace, eventHubName, consumerGroup, ex.Message);
-                throw new RequestFailedException(Resources.BlobsResourceDoesNotExist);
+                ListOwnershipError(fullyQualifiedNamespace, eventHubName, consumerGroup, ex.Message);
+                throw new RequestFailedException(BlobsResourceDoesNotExist);
             }
             finally
             {
-                Logger.ListOwnershipComplete(fullyQualifiedNamespace, eventHubName, consumerGroup, result?.Count ?? 0);
+                ListOwnershipComplete(fullyQualifiedNamespace, eventHubName, consumerGroup, result?.Count ?? 0);
             }
         }
 
@@ -169,7 +166,7 @@ public override async Task<IEnumerable<EventProcessorPartitionOwnership>> ClaimO
 
             foreach (EventProcessorPartitionOwnership ownership in partitionOwnership)
             {
-                Logger.ClaimOwnershipStart(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier);
+                ClaimOwnershipStart(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier);
                 metadata[BlobMetadataKey.OwnerIdentifier] = ownership.OwnerIdentifier;
 
                 var blobRequestConditions = new BlobRequestConditions();
@@ -199,7 +196,7 @@ async Task<Response<BlobContentInfo>> uploadBlobAsync(CancellationToken uploadTo
                                 // A blob could have just been created by another Event Processor that claimed ownership of this
                                 // partition.  In this case, there's no point in retrying because we don't have the correct ETag.
 
-                                Logger.OwnershipNotClaimable(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.Message);
+                                OwnershipNotClaimable(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.Message);
                                 return null;
                             }
                         };
@@ -234,25 +231,25 @@ async Task<Response<BlobContentInfo>> uploadBlobAsync(CancellationToken uploadTo
                     }
 
                     claimedOwnership.Add(ownership);
-                    Logger.OwnershipClaimed(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier);
+                    OwnershipClaimed(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier);
                 }
                 catch (RequestFailedException ex) when (ex.ErrorCode == BlobErrorCode.ConditionNotMet)
                 {
-                    Logger.OwnershipNotClaimable(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.ToString());
+                    OwnershipNotClaimable(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.ToString());
                 }
                 catch (RequestFailedException ex) when (ex.ErrorCode == BlobErrorCode.ContainerNotFound || ex.ErrorCode == BlobErrorCode.BlobNotFound)
                 {
-                    Logger.ClaimOwnershipError(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.Message);
-                    throw new RequestFailedException(Resources.BlobsResourceDoesNotExist);
+                    ClaimOwnershipError(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.Message);
+                    throw new RequestFailedException(BlobsResourceDoesNotExist);
                 }
                 catch (Exception ex)
                 {
-                    Logger.ClaimOwnershipError(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.Message);
+                    ClaimOwnershipError(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier, ex.Message);
                     throw;
                 }
                 finally
                 {
-                    Logger.ClaimOwnershipComplete(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier);
+                    ClaimOwnershipComplete(ownership.PartitionId, ownership.FullyQualifiedNamespace, ownership.EventHubName, ownership.ConsumerGroup, ownership.OwnerIdentifier);
                 }
             }
 
@@ -276,7 +273,7 @@ public override async Task<IEnumerable<EventProcessorCheckpoint>> ListCheckpoint
                                                                                                CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested<TaskCanceledException>();
-            Logger.ListCheckpointsStart(fullyQualifiedNamespace, eventHubName, consumerGroup);
+            ListCheckpointsStart(fullyQualifiedNamespace, eventHubName, consumerGroup);
 
             var prefix = string.Format(CultureInfo.InvariantCulture, CheckpointPrefix, fullyQualifiedNamespace.ToLowerInvariant(), eventHubName.ToLowerInvariant(), consumerGroup.ToLowerInvariant());
             var checkpointCount = 0;
@@ -315,7 +312,7 @@ async Task<IEnumerable<EventProcessorCheckpoint>> listCheckpointsAsync(Cancellat
                     }
                     else
                     {
-                        Logger.InvalidCheckpointFound(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup);
+                        InvalidCheckpointFound(partitionId, fullyQualifiedNamespace, eventHubName, consumerGroup);
                     }
                 }
 
@@ -329,17 +326,17 @@ async Task<IEnumerable<EventProcessorCheckpoint>> listCheckpointsAsync(Cancellat
             }
             catch (RequestFailedException ex) when (ex.ErrorCode == BlobErrorCode.ContainerNotFound)
             {
-                Logger.ListCheckpointsError(fullyQualifiedNamespace, eventHubName, consumerGroup, ex.Message);
-                throw new RequestFailedException(Resources.BlobsResourceDoesNotExist);
+                ListCheckpointsError(fullyQualifiedNamespace, eventHubName, consumerGroup, ex.Message);
+                throw new RequestFailedException(BlobsResourceDoesNotExist);
             }
             catch (Exception ex)
             {
-                Logger.ListCheckpointsError(fullyQualifiedNamespace, eventHubName, consumerGroup, ex.Message);
+                ListCheckpointsError(fullyQualifiedNamespace, eventHubName, consumerGroup, ex.Message);
                 throw;
             }
             finally
             {
-                Logger.ListCheckpointsComplete(fullyQualifiedNamespace, eventHubName, consumerGroup, checkpointCount);
+                ListCheckpointsComplete(fullyQualifiedNamespace, eventHubName, consumerGroup, checkpointCount);
             }
         }
 
@@ -358,7 +355,7 @@ public override async Task UpdateCheckpointAsync(EventProcessorCheckpoint checkp
                                                          CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested<TaskCanceledException>();
-            Logger.UpdateCheckpointStart(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup);
+            UpdateCheckpointStart(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup);
 
             var blobName = string.Format(CultureInfo.InvariantCulture, CheckpointPrefix + checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace.ToLowerInvariant(), checkpoint.EventHubName.ToLowerInvariant(), checkpoint.ConsumerGroup.ToLowerInvariant());
             var blobClient = ContainerClient.GetBlobClient(blobName);
@@ -391,17 +388,17 @@ await ApplyRetryPolicy(async token =>
             }
             catch (RequestFailedException ex) when (ex.ErrorCode == BlobErrorCode.ContainerNotFound)
             {
-                Logger.UpdateCheckpointError(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup, ex.Message);
-                throw new RequestFailedException(Resources.BlobsResourceDoesNotExist);
+                UpdateCheckpointError(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup, ex.Message);
+                throw new RequestFailedException(BlobsResourceDoesNotExist);
             }
             catch (Exception ex)
             {
-                Logger.UpdateCheckpointError(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup, ex.Message);
+                UpdateCheckpointError(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup, ex.Message);
                 throw;
             }
             finally
             {
-                Logger.UpdateCheckpointComplete(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup);
+                UpdateCheckpointComplete(checkpoint.PartitionId, checkpoint.FullyQualifiedNamespace, checkpoint.EventHubName, checkpoint.ConsumerGroup);
             }
         }
 
@@ -490,5 +487,186 @@ async Task wrapper(CancellationToken token)
             await ApplyRetryPolicy(wrapper, cancellationToken).ConfigureAwait(false);
             return result;
         }
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of ownership has completed.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        /// <param name="ownershipCount">The amount of ownership received from the storage service.</param>
+        ///
+        partial void ListOwnershipComplete(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, int ownershipCount);
+
+        /// <summary>
+        ///   Indicates that an unhandled exception was encountered while retrieving a list of ownership.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void ListOwnershipError(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string errorMessage);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of ownership has started.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        ///
+        partial void ListOwnershipStart(string fullyQualifiedNamespace, string eventHubName, string consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of checkpoints has completed.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoints are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoints are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoints are associated with.</param>
+        /// <param name="checkpointCount">The amount of checkpoints received from the storage service.</param>
+        ///
+        partial void ListCheckpointsComplete(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, int checkpointCount);
+
+        /// <summary>
+        ///   Indicates that an unhandled exception was encountered while retrieving a list of checkpoints.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoints are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoints are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership are associated with.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void ListCheckpointsError(string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string errorMessage);
+
+        /// <summary>
+        ///   Indicates that invalid checkpoint data was found during an attempt to retrieve a list of checkpoints.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition the data is associated with.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the data is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the data is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the data is associated with.</param>
+        ///
+        partial void InvalidCheckpointFound(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve a list of checkpoints has started.
+        /// </summary>
+        ///
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoints are associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoints are associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoints are associated with.</param>
+        ///
+        partial void ListCheckpointsStart(string fullyQualifiedNamespace, string eventHubName, string consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an unhandled exception was encountered while updating a checkpoint.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being checkpointed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoint is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoint is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoint is associated with.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void UpdateCheckpointError(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string errorMessage);
+
+        /// <summary>
+        ///   Indicates that an attempt to update a checkpoint has completed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being checkpointed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoint is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoint is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoint is associated with.</param>
+        ///
+        partial void UpdateCheckpointComplete(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to create/update a checkpoint has started.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being checkpointed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the checkpoint is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the checkpoint is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the checkpoint is associated with.</param>
+        ///
+        partial void UpdateCheckpointStart(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup);
+
+        /// <summary>
+        ///   Indicates that an attempt to retrieve claim partition ownership has completed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        ///
+        partial void ClaimOwnershipComplete(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier);
+
+        /// <summary>
+        ///   Indicates that an exception was encountered while attempting to retrieve claim partition ownership.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        /// <param name="errorMessage">The message for the exception that occurred.</param>
+        ///
+        partial void ClaimOwnershipError(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier, string errorMessage);
+
+        /// <summary>
+        ///   Indicates that ownership was unable to be claimed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        /// <param name="message">The message for the failure.</param>
+        ///
+        partial void OwnershipNotClaimable(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier, string message);
+
+        /// <summary>
+        ///   Indicates that ownership was successfully claimed.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        ///
+        partial void OwnershipClaimed(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier);
+
+        /// <summary>
+        ///   Indicates that an attempt to claim a partition ownership has started.
+        /// </summary>
+        ///
+        /// <param name="partitionId">The identifier of the partition being claimed.</param>
+        /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace the ownership is associated with.  This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param>
+        /// <param name="eventHubName">The name of the specific Event Hub the ownership is associated with, relative to the Event Hubs namespace that contains it.</param>
+        /// <param name="consumerGroup">The name of the consumer group the ownership is associated with.</param>
+        /// <param name="ownerIdentifier">The identifier of the processor that attempted to claim the ownership for.</param>
+        ///
+        partial void ClaimOwnershipStart(string partitionId, string fullyQualifiedNamespace, string eventHubName, string consumerGroup, string ownerIdentifier);
+
+        /// <summary>
+        ///   Indicates that a <see cref="BlobsCheckpointStore" /> was created.
+        /// </summary>
+        ///
+        /// <param name="typeName">The type name for the checkpoint store.</param>
+        /// <param name="accountName">The Storage account name corresponding to the associated container client.</param>
+        /// <param name="containerName">The name of the associated container client.</param>
+        ///
+        partial void BlobsCheckpointStoreCreated(string typeName, string accountName, string containerName);
     }
 }
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Resources.resx b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Resources.resx
index 5ba5bb875a57..40c511371738 100644
--- a/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Resources.resx
+++ b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Resources.resx
@@ -234,9 +234,6 @@
   <data name="ClientNeededForThisInformation" xml:space="preserve">
     <value>The Event Hub client responsible for this information is not available.</value>
   </data>
-  <data name="BlobsResourceDoesNotExist" xml:space="preserve">
-    <value>The Azure Storage Blobs container or blob used by the Event Processor Client does not exist.</value>
-  </data>
   <data name="CannotCreateCheckpointForEmptyEvent" xml:space="preserve">
     <value>A checkpoint cannot be created or updated using an empty event.</value>
   </data>
@@ -300,4 +297,4 @@
   <data name="IdempotentAlreadyPublished" xml:space="preserve">
     <value>These events have already been successfully published.  When idempotent publishing is enabled, events that were acknowledged by the Event Hubs service may not be published again.</value>
   </data>
-</root>
+</root>
\ No newline at end of file