diff --git a/sdk/storage/azure-storage-blobs/CHANGELOG.md b/sdk/storage/azure-storage-blobs/CHANGELOG.md
index 5486da345..5f4191c55 100644
--- a/sdk/storage/azure-storage-blobs/CHANGELOG.md
+++ b/sdk/storage/azure-storage-blobs/CHANGELOG.md
@@ -2,6 +2,9 @@
 
 ## 12.0.0-beta.9 (Unreleased)
 
+### New Features
+
+- Added support for customized application ID.
 
 ## 12.0.0-beta.8 (2021-02-12)
 
diff --git a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_options.hpp b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_options.hpp
index 1e3ed2548..c21a5919d 100644
--- a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_options.hpp
+++ b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_options.hpp
@@ -155,6 +155,16 @@ namespace Azure { namespace Storage { namespace Blobs {
      * @brief Customized HTTP client. We're going to use the default one if this is empty.
      */
     Azure::Core::Http::TransportPolicyOptions TransportPolicyOptions;
+
+    /**
+     * @brief The last part of the user agent for telemetry.
+     */
+    std::string ApplicationId;
+
+    /**
+     * API version used by this client.
+     */
+    std::string ApiVersion = Details::ApiVersion;
   };
 
   /**
diff --git a/sdk/storage/azure-storage-blobs/src/blob_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_client.cpp
index 890cb7776..4b9ed74a0 100644
--- a/sdk/storage/azure-storage-blobs/src/blob_client.cpp
+++ b/sdk/storage/azure-storage-blobs/src/blob_client.cpp
@@ -10,7 +10,6 @@
 #include <azure/storage/common/reliable_stream.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
 
 #include "azure/storage/blobs/append_blob_client.hpp"
 #include "azure/storage/blobs/block_blob_client.hpp"
@@ -46,25 +45,16 @@ namespace Azure { namespace Storage { namespace Blobs {
       const BlobClientOptions& options)
       : BlobClient(blobUrl, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   BlobClient::BlobClient(
@@ -73,57 +63,35 @@ namespace Azure { namespace Storage { namespace Blobs {
       const BlobClientOptions& options)
       : BlobClient(blobUrl, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    Azure::Core::Http::TokenRequestOptions tokenOptions;
+    tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
+                credential, tokenOptions),
+            options));
   }
 
   BlobClient::BlobClient(const std::string& blobUrl, const BlobClientOptions& options)
       : m_blobUrl(blobUrl), m_customerProvidedKey(options.CustomerProvidedKey),
         m_encryptionScope(options.EncryptionScope)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   BlockBlobClient BlobClient::AsBlockBlobClient() const { return BlockBlobClient(*this); }
diff --git a/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp
index 6f268756b..cc124c14b 100644
--- a/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp
+++ b/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp
@@ -7,7 +7,6 @@
 #include <azure/storage/common/constants.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
 
 #include "azure/storage/blobs/append_blob_client.hpp"
 #include "azure/storage/blobs/block_blob_client.hpp"
@@ -42,25 +41,16 @@ namespace Azure { namespace Storage { namespace Blobs {
       const BlobClientOptions& options)
       : BlobContainerClient(blobContainerUrl, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   BlobContainerClient::BlobContainerClient(
@@ -69,33 +59,19 @@ namespace Azure { namespace Storage { namespace Blobs {
       const BlobClientOptions& options)
       : BlobContainerClient(blobContainerUrl, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    Azure::Core::Http::TokenRequestOptions tokenOptions;
+    tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
+                credential, tokenOptions),
+            options));
   }
 
   BlobContainerClient::BlobContainerClient(
@@ -104,24 +80,16 @@ namespace Azure { namespace Storage { namespace Blobs {
       : m_blobContainerUrl(blobContainerUrl), m_customerProvidedKey(options.CustomerProvidedKey),
         m_encryptionScope(options.EncryptionScope)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   BlobClient BlobContainerClient::GetBlobClient(const std::string& blobName) const
diff --git a/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp
index 66c2ccfc7..1002502fc 100644
--- a/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp
+++ b/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp
@@ -7,7 +7,6 @@
 #include <azure/storage/common/constants.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
 
 #include "azure/storage/blobs/version.hpp"
 
@@ -37,25 +36,16 @@ namespace Azure { namespace Storage { namespace Blobs {
       const BlobClientOptions& options)
       : m_serviceUrl(serviceUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   BlobServiceClient::BlobServiceClient(
@@ -64,33 +54,19 @@ namespace Azure { namespace Storage { namespace Blobs {
       const BlobClientOptions& options)
       : m_serviceUrl(serviceUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    Azure::Core::Http::TokenRequestOptions tokenOptions;
+    tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
+                credential, tokenOptions),
+            options));
   }
 
   BlobServiceClient::BlobServiceClient(
@@ -98,24 +74,16 @@ namespace Azure { namespace Storage { namespace Blobs {
       const BlobClientOptions& options)
       : m_serviceUrl(serviceUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   BlobContainerClient BlobServiceClient::GetBlobContainerClient(
diff --git a/sdk/storage/azure-storage-common/inc/azure/storage/common/storage_common.hpp b/sdk/storage/azure-storage-common/inc/azure/storage/common/storage_common.hpp
index e5bf35994..4b7846a79 100644
--- a/sdk/storage/azure-storage-common/inc/azure/storage/common/storage_common.hpp
+++ b/sdk/storage/azure-storage-common/inc/azure/storage/common/storage_common.hpp
@@ -6,11 +6,17 @@
 #include <algorithm>
 #include <cstdint>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
+#include <azure/core/http/policy.hpp>
 #include <azure/core/internal/strings.hpp>
 
+#include "azure/storage/common/constants.hpp"
+#include "azure/storage/common/storage_per_retry_policy.hpp"
+#include "azure/storage/common/storage_retry_policy.hpp"
+
 namespace Azure { namespace Storage {
 
   /**
@@ -62,4 +68,58 @@ namespace Azure { namespace Storage {
   } // namespace Details
   using Metadata = std::map<std::string, std::string, Details::CaseInsensitiveComparator>;
 
+  namespace Details {
+
+    /*
+     * Policies order:
+     * Shared built-in per-operation policies
+     * Service-specific built-in per-operation policies
+     * Customer-defined per-operation policies
+     * Retry policy
+     * Shared built-in per-retry policies
+     * Service-specific built-in per-retry policies
+     * Customer-defined per-retry policies
+     * Authentication policy
+     * Transport policy
+     */
+
+    template <class T>
+    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> ConstructPolicies(
+        std::unique_ptr<Azure::Core::Http::HttpPolicy> serviceBuiltinPerOperationPolicy,
+        std::unique_ptr<Azure::Core::Http::HttpPolicy> authenticationPolicy,
+        T&& clientOptions)
+    {
+      std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
+      {
+        Azure::Core::Http::Internal::ValuePolicyOptions options;
+        options.HeaderValues[Details::HttpHeaderXMsVersion] = clientOptions.ApiVersion;
+        policies.emplace_back(std::make_unique<Azure::Core::Http::Internal::ValuePolicy>(options));
+      }
+      policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
+      if (serviceBuiltinPerOperationPolicy)
+      {
+        policies.emplace_back(std::move(serviceBuiltinPerOperationPolicy));
+      }
+      for (const auto& p : clientOptions.PerOperationPolicies)
+      {
+        policies.emplace_back(p->Clone());
+      }
+      policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(
+          std::forward<T>(clientOptions).RetryOptions));
+      policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
+      for (const auto& p : clientOptions.PerRetryPolicies)
+      {
+        policies.emplace_back(p->Clone());
+      }
+      if (authenticationPolicy)
+      {
+        policies.emplace_back(std::move(authenticationPolicy));
+      }
+      policies.emplace_back(std::make_unique<Azure::Core::Http::TransportPolicy>(
+          std::forward<T>(clientOptions).TransportPolicyOptions));
+      return policies;
+    }
+
+  } // namespace Details
+
 }} // namespace Azure::Storage
diff --git a/sdk/storage/azure-storage-files-datalake/CHANGELOG.md b/sdk/storage/azure-storage-files-datalake/CHANGELOG.md
index 15ec33c96..b92d3ec01 100644
--- a/sdk/storage/azure-storage-files-datalake/CHANGELOG.md
+++ b/sdk/storage/azure-storage-files-datalake/CHANGELOG.md
@@ -2,6 +2,13 @@
 
 ## 12.0.0-beta.9 (Unreleased)
 
+### New Features
+
+- Added support for customized application ID.
+
+### Breaking Changes
+
+- DataLake client constructors won't automatically convert blob url to dfs url anymore.
 
 ## 12.0.0-beta.8 (2021-02-12)
 
diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_file_client.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_file_client.hpp
index 49259e3e0..6df799f2e 100644
--- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_file_client.hpp
+++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_file_client.hpp
@@ -73,7 +73,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
      *
      * @return The file's primary url endpoint.
      */
-    std::string GetUrl() const { return m_blockBlobClient.GetUrl(); }
+    std::string GetUrl() const { return m_blobClient.GetUrl(); }
 
     /**
      * @brief Uploads data to be appended to a file. Data can only be appended to a file.
@@ -267,15 +267,11 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         const Azure::Core::Context& context = Azure::Core::Context()) const;
 
   private:
-    Blobs::BlockBlobClient m_blockBlobClient;
-
     explicit DataLakeFileClient(
         Azure::Core::Http::Url fileUrl,
         Blobs::BlobClient blobClient,
-        Blobs::BlockBlobClient blockBlobClient,
         std::shared_ptr<Azure::Core::Internal::Http::HttpPipeline> pipeline)
-        : DataLakePathClient(std::move(fileUrl), std::move(blobClient), pipeline),
-          m_blockBlobClient(std::move(blockBlobClient))
+        : DataLakePathClient(std::move(fileUrl), std::move(blobClient), pipeline)
     {
     }
 
diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp
index 8c6b4d265..2e3176466 100644
--- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp
+++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp
@@ -47,6 +47,16 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
      * @brief Customized HTTP client. We're going to use the default one if this is empty.
      */
     Azure::Core::Http::TransportPolicyOptions TransportPolicyOptions;
+
+    /**
+     * @brief The last part of the user agent for telemetry.
+     */
+    std::string ApplicationId;
+
+    /**
+     * API version used by this client.
+     */
+    std::string ApiVersion = Details::DefaultServiceApiVersion;
   };
 
   /**
diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_utilities.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_utilities.hpp
index a9a4916c5..9aaff7ad0 100644
--- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_utilities.hpp
+++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_utilities.hpp
@@ -5,8 +5,11 @@
 
 #include <string>
 
+#include <azure/storage/blobs/blob_options.hpp>
 #include <azure/storage/common/storage_common.hpp>
 
+#include "azure/storage/files/datalake/datalake_options.hpp"
+
 namespace Azure { namespace Storage { namespace Files { namespace DataLake { namespace Details {
 
   std::string GetBlobUrlFromUrl(const std::string& url);
@@ -21,4 +24,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
 
   bool MetadataIncidatesIsDirectory(const Storage::Metadata& metadata);
 
+  Blobs::BlobClientOptions GetBlobClientOptions(const DataLakeClientOptions& options);
+
 }}}}} // namespace Azure::Storage::Files::DataLake::Details
diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_directory_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_directory_client.cpp
index 0865345e3..92d10ef3b 100644
--- a/sdk/storage/azure-storage-files-datalake/src/datalake_directory_client.cpp
+++ b/sdk/storage/azure-storage-files-datalake/src/datalake_directory_client.cpp
@@ -8,8 +8,6 @@
 #include <azure/storage/common/crypt.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/datalake/datalake_file_client.hpp"
 #include "azure/storage/files/datalake/datalake_utilities.hpp"
@@ -45,28 +43,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const DataLakeClientOptions& options)
       : DataLakePathClient(directoryUrl, credential, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
   }
 
   DataLakeDirectoryClient::DataLakeDirectoryClient(
@@ -75,35 +51,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const DataLakeClientOptions& options)
       : DataLakePathClient(directoryUrl, credential, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
   }
 
   DataLakeDirectoryClient::DataLakeDirectoryClient(
@@ -111,26 +58,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const DataLakeClientOptions& options)
       : DataLakePathClient(directoryUrl, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
   }
 
   DataLakeFileClient DataLakeDirectoryClient::GetFileClient(const std::string& fileName) const
@@ -139,9 +66,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     builder.AppendPath(Storage::Details::UrlEncodePath(fileName));
     auto blobClient = m_blobClient;
     blobClient.m_blobUrl.AppendPath(Storage::Details::UrlEncodePath(fileName));
-    auto blockBlobClient = blobClient.AsBlockBlobClient();
-    return DataLakeFileClient(
-        std::move(builder), std::move(blobClient), std::move(blockBlobClient), m_pipeline);
+    return DataLakeFileClient(std::move(builder), std::move(blobClient), m_pipeline);
   }
 
   DataLakeDirectoryClient DataLakeDirectoryClient::GetSubdirectoryClient(
@@ -192,12 +117,8 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     // Initialize the file client.
     auto blobClient = m_blobClient;
     blobClient.m_blobUrl.SetPath(destinationDfsUrl.GetPath());
-    auto blockBlobClient = blobClient.AsBlockBlobClient();
-    auto renamedFileClient = DataLakeFileClient(
-        std::move(destinationDfsUrl),
-        std::move(blobClient),
-        std::move(blockBlobClient),
-        m_pipeline);
+    auto renamedFileClient
+        = DataLakeFileClient(std::move(destinationDfsUrl), std::move(blobClient), m_pipeline);
     return Azure::Core::Response<DataLakeFileClient>(
         std::move(renamedFileClient), result.ExtractRawResponse());
   }
diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
index 5c837eec6..feb33042c 100644
--- a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
+++ b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
@@ -8,8 +8,6 @@
 #include <azure/storage/common/crypt.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/datalake/datalake_constants.hpp"
 #include "azure/storage/files/datalake/datalake_utilities.hpp"
@@ -106,98 +104,23 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const std::string& fileUrl,
       std::shared_ptr<StorageSharedKeyCredential> credential,
       const DataLakeClientOptions& options)
-      : DataLakePathClient(fileUrl, credential, options),
-        m_blockBlobClient(m_blobClient.AsBlockBlobClient())
+      : DataLakePathClient(fileUrl, credential, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
   }
 
   DataLakeFileClient::DataLakeFileClient(
       const std::string& fileUrl,
       std::shared_ptr<Core::TokenCredential> credential,
       const DataLakeClientOptions& options)
-      : DataLakePathClient(fileUrl, credential, options),
-        m_blockBlobClient(m_blobClient.AsBlockBlobClient())
+      : DataLakePathClient(fileUrl, credential, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
   }
 
   DataLakeFileClient::DataLakeFileClient(
       const std::string& fileUrl,
       const DataLakeClientOptions& options)
-      : DataLakePathClient(fileUrl, options), m_blockBlobClient(m_blobClient.AsBlockBlobClient())
+      : DataLakePathClient(fileUrl, options)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
   }
 
   Azure::Core::Response<Models::AppendDataLakeFileResult> DataLakeFileClient::Append(
@@ -348,7 +271,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     blobOptions.TransferOptions.Concurrency = options.TransferOptions.Concurrency;
     blobOptions.HttpHeaders = FromPathHttpHeaders(options.HttpHeaders);
     blobOptions.Metadata = options.Metadata;
-    return m_blockBlobClient.UploadFrom(fileName, blobOptions, context);
+    return m_blobClient.AsBlockBlobClient().UploadFrom(fileName, blobOptions, context);
   }
 
   Azure::Core::Response<Models::UploadDataLakeFileFromResult> DataLakeFileClient::UploadFrom(
@@ -364,7 +287,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     blobOptions.TransferOptions.Concurrency = options.TransferOptions.Concurrency;
     blobOptions.HttpHeaders = FromPathHttpHeaders(options.HttpHeaders);
     blobOptions.Metadata = options.Metadata;
-    return m_blockBlobClient.UploadFrom(buffer, bufferSize, blobOptions, context);
+    return m_blobClient.AsBlockBlobClient().UploadFrom(buffer, bufferSize, blobOptions, context);
   }
 
   Azure::Core::Response<Models::DownloadDataLakeFileToResult> DataLakeFileClient::DownloadTo(
@@ -373,7 +296,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const DownloadDataLakeFileToOptions& options,
       const Azure::Core::Context& context) const
   {
-    auto result = m_blockBlobClient.DownloadTo(buffer, bufferSize, options, context);
+    auto result = m_blobClient.AsBlockBlobClient().DownloadTo(buffer, bufferSize, options, context);
     Models::DownloadDataLakeFileToResult ret;
     ret.ContentRange = std::move(result->ContentRange);
     ret.FileSize = result->BlobSize;
@@ -415,7 +338,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const DownloadDataLakeFileToOptions& options,
       const Azure::Core::Context& context) const
   {
-    auto result = m_blockBlobClient.DownloadTo(fileName, options, context);
+    auto result = m_blobClient.AsBlockBlobClient().DownloadTo(fileName, options, context);
     Models::DownloadDataLakeFileToResult ret;
     ret.ContentRange = std::move(result->ContentRange);
     ret.FileSize = result->BlobSize;
diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_file_system_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_file_system_client.cpp
index 253d4fe6f..19dd4592a 100644
--- a/sdk/storage/azure-storage-files-datalake/src/datalake_file_system_client.cpp
+++ b/sdk/storage/azure-storage-files-datalake/src/datalake_file_system_client.cpp
@@ -9,8 +9,6 @@
 #include <azure/storage/common/crypt.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/datalake/datalake_constants.hpp"
 #include "azure/storage/files/datalake/datalake_directory_client.hpp"
@@ -20,24 +18,6 @@
 #include "azure/storage/files/datalake/version.hpp"
 
 namespace Azure { namespace Storage { namespace Files { namespace DataLake {
-  namespace {
-    Blobs::BlobClientOptions GetBlobContainerClientOptions(const DataLakeClientOptions& options)
-    {
-      Blobs::BlobClientOptions blobOptions;
-      for (const auto& p : options.PerOperationPolicies)
-      {
-        blobOptions.PerOperationPolicies.emplace_back(p->Clone());
-      }
-      for (const auto& p : options.PerRetryPolicies)
-      {
-        blobOptions.PerRetryPolicies.emplace_back(p->Clone());
-      }
-      blobOptions.RetryOptions = options.RetryOptions;
-      blobOptions.RetryOptions.SecondaryHostForRetryReads
-          = Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-      return blobOptions;
-    }
-  } // namespace
 
   DataLakeFileSystemClient DataLakeFileSystemClient::CreateFromConnectionString(
       const std::string& connectionString,
@@ -63,119 +43,72 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const std::string& fileSystemUrl,
       std::shared_ptr<StorageSharedKeyCredential> credential,
       const DataLakeClientOptions& options)
-      : m_fileSystemUrl(Details::GetDfsUrlFromUrl(fileSystemUrl)),
-        m_blobContainerClient(
-            Details::GetBlobUrlFromUrl(fileSystemUrl),
-            credential,
-            GetBlobContainerClientOptions(options))
+      : m_fileSystemUrl(fileSystemUrl), m_blobContainerClient(
+                                            Details::GetBlobUrlFromUrl(fileSystemUrl),
+                                            credential,
+                                            Details::GetBlobClientOptions(options))
   {
-
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   DataLakeFileSystemClient::DataLakeFileSystemClient(
       const std::string& fileSystemUrl,
       std::shared_ptr<Core::TokenCredential> credential,
       const DataLakeClientOptions& options)
-      : m_fileSystemUrl(Details::GetDfsUrlFromUrl(fileSystemUrl)),
-        m_blobContainerClient(
-            Details::GetBlobUrlFromUrl(fileSystemUrl),
-            credential,
-            GetBlobContainerClientOptions(options))
+      : m_fileSystemUrl(fileSystemUrl), m_blobContainerClient(
+                                            Details::GetBlobUrlFromUrl(fileSystemUrl),
+                                            credential,
+                                            Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    Azure::Core::Http::TokenRequestOptions tokenOptions;
+    tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
+                credential, tokenOptions),
+            options));
   }
 
   DataLakeFileSystemClient::DataLakeFileSystemClient(
       const std::string& fileSystemUrl,
       const DataLakeClientOptions& options)
-      : m_fileSystemUrl(Details::GetDfsUrlFromUrl(fileSystemUrl)),
-        m_blobContainerClient(
-            Details::GetBlobUrlFromUrl(fileSystemUrl),
-            GetBlobContainerClientOptions(options))
+      : m_fileSystemUrl(fileSystemUrl), m_blobContainerClient(
+                                            Details::GetBlobUrlFromUrl(fileSystemUrl),
+                                            Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   DataLakeFileClient DataLakeFileSystemClient::GetFileClient(const std::string& fileName) const
   {
-
     auto builder = m_fileSystemUrl;
     builder.AppendPath(Storage::Details::UrlEncodePath(fileName));
     auto blobClient = m_blobContainerClient.GetBlobClient(fileName);
-    auto blockBlobClient = blobClient.AsBlockBlobClient();
-    return DataLakeFileClient(
-        std::move(builder), std::move(blobClient), std::move(blockBlobClient), m_pipeline);
+    return DataLakeFileClient(std::move(builder), std::move(blobClient), m_pipeline);
   }
 
   DataLakeDirectoryClient DataLakeFileSystemClient::GetDirectoryClient(
diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp
index ac2f5a5dc..671aff0e1 100644
--- a/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp
+++ b/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp
@@ -8,32 +8,14 @@
 #include <azure/storage/common/crypt.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/datalake/datalake_constants.hpp"
 #include "azure/storage/files/datalake/datalake_utilities.hpp"
 #include "azure/storage/files/datalake/version.hpp"
 
 namespace Azure { namespace Storage { namespace Files { namespace DataLake {
-  namespace {
-    Blobs::BlobClientOptions GetBlobClientOptions(const DataLakeClientOptions& options)
-    {
-      Blobs::BlobClientOptions blobOptions;
-      for (const auto& p : options.PerOperationPolicies)
-      {
-        blobOptions.PerOperationPolicies.emplace_back(p->Clone());
-      }
-      for (const auto& p : options.PerRetryPolicies)
-      {
-        blobOptions.PerRetryPolicies.emplace_back(p->Clone());
-      }
-      blobOptions.RetryOptions = options.RetryOptions;
-      blobOptions.RetryOptions.SecondaryHostForRetryReads
-          = Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-      return blobOptions;
-    }
 
+  namespace {
     Models::LeaseStateType FromBlobLeaseState(Blobs::Models::BlobLeaseState state)
     {
       if (state == Blobs::Models::BlobLeaseState::Available)
@@ -99,100 +81,63 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const std::string& pathUrl,
       std::shared_ptr<StorageSharedKeyCredential> credential,
       const DataLakeClientOptions& options)
-      : m_pathUrl(Details::GetDfsUrlFromUrl(pathUrl)),
-        m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), credential, GetBlobClientOptions(options))
+      : m_pathUrl(pathUrl), m_blobClient(
+                                Details::GetBlobUrlFromUrl(pathUrl),
+                                credential,
+                                Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   DataLakePathClient::DataLakePathClient(
       const std::string& pathUrl,
       std::shared_ptr<Core::TokenCredential> credential,
       const DataLakeClientOptions& options)
-      : m_pathUrl(Details::GetDfsUrlFromUrl(pathUrl)),
-        m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), credential, GetBlobClientOptions(options))
+      : m_pathUrl(pathUrl), m_blobClient(
+                                Details::GetBlobUrlFromUrl(pathUrl),
+                                credential,
+                                Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    Azure::Core::Http::TokenRequestOptions tokenOptions;
+    tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
+                credential, tokenOptions),
+            options));
   }
 
   DataLakePathClient::DataLakePathClient(
       const std::string& pathUrl,
       const DataLakeClientOptions& options)
-      : m_pathUrl(Details::GetDfsUrlFromUrl(pathUrl)),
-        m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), GetBlobClientOptions(options))
+      : m_pathUrl(pathUrl),
+        m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-
-    Azure::Core::Http::TransportPolicyOptions transportPolicyOptions;
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   Azure::Core::Response<Models::SetDataLakePathAccessControlListResult>
diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp
index e4e8d3980..f12fa008e 100644
--- a/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp
+++ b/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp
@@ -9,32 +9,14 @@
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
 #include <azure/storage/common/storage_credential.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/datalake/datalake_file_system_client.hpp"
 #include "azure/storage/files/datalake/datalake_utilities.hpp"
 #include "azure/storage/files/datalake/version.hpp"
 
 namespace Azure { namespace Storage { namespace Files { namespace DataLake {
-  namespace {
-    Blobs::BlobClientOptions GetBlobServiceClientOptions(const DataLakeClientOptions& options)
-    {
-      Blobs::BlobClientOptions blobOptions;
-      for (const auto& p : options.PerOperationPolicies)
-      {
-        blobOptions.PerOperationPolicies.emplace_back(p->Clone());
-      }
-      for (const auto& p : options.PerRetryPolicies)
-      {
-        blobOptions.PerRetryPolicies.emplace_back(p->Clone());
-      }
-      blobOptions.RetryOptions = options.RetryOptions;
-      blobOptions.RetryOptions.SecondaryHostForRetryReads
-          = Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-      return blobOptions;
-    }
 
+  namespace {
     std::vector<Models::FileSystemItem> FileSystemsFromContainerItems(
         std::vector<Blobs::Models::BlobContainerItem> items)
     {
@@ -100,104 +82,64 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       const std::string& serviceUrl,
       std::shared_ptr<StorageSharedKeyCredential> credential,
       const DataLakeClientOptions& options)
-      : m_serviceUrl(Details::GetDfsUrlFromUrl(serviceUrl)),
-        m_blobServiceClient(
-            Details::GetBlobUrlFromUrl(serviceUrl),
-            credential,
-            GetBlobServiceClientOptions(options))
+      : m_serviceUrl(serviceUrl), m_blobServiceClient(
+                                      Details::GetBlobUrlFromUrl(serviceUrl),
+                                      credential,
+                                      Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   DataLakeServiceClient::DataLakeServiceClient(
       const std::string& serviceUrl,
       std::shared_ptr<Core::TokenCredential> credential,
       const DataLakeClientOptions& options)
-      : m_serviceUrl(Details::GetDfsUrlFromUrl(serviceUrl)),
-        m_blobServiceClient(
-            Details::GetBlobUrlFromUrl(serviceUrl),
-            credential,
-            GetBlobServiceClientOptions(options))
+      : m_serviceUrl(serviceUrl), m_blobServiceClient(
+                                      Details::GetBlobUrlFromUrl(serviceUrl),
+                                      credential,
+                                      Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-
-    {
-      Azure::Core::Http::TokenRequestOptions const tokenOptions
-          = {{Storage::Details::StorageScope}};
-
-      policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
-          credential, tokenOptions));
-    }
-
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    Azure::Core::Http::TokenRequestOptions tokenOptions;
+    tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
+                credential, tokenOptions),
+            options));
   }
 
   DataLakeServiceClient::DataLakeServiceClient(
       const std::string& serviceUrl,
       const DataLakeClientOptions& options)
-      : m_serviceUrl(Details::GetDfsUrlFromUrl(serviceUrl)),
-        m_blobServiceClient(
-            Details::GetBlobUrlFromUrl(serviceUrl),
-            GetBlobServiceClientOptions(options))
+      : m_serviceUrl(serviceUrl), m_blobServiceClient(
+                                      Details::GetBlobUrlFromUrl(serviceUrl),
+                                      Details::GetBlobClientOptions(options))
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
-    dfsRetryOptions.SecondaryHostForRetryReads
-        = Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
-    policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   DataLakeFileSystemClient DataLakeServiceClient::GetFileSystemClient(
diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_utilities.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_utilities.cpp
index 2409ffb0b..45aa4b506 100644
--- a/sdk/storage/azure-storage-files-datalake/src/datalake_utilities.cpp
+++ b/sdk/storage/azure-storage-files-datalake/src/datalake_utilities.cpp
@@ -72,4 +72,25 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
     auto ite = metadata.find(DataLakeIsDirectoryKey);
     return ite != metadata.end() && ite->second == "true";
   }
+
+  Blobs::BlobClientOptions GetBlobClientOptions(const DataLakeClientOptions& options)
+  {
+    Blobs::BlobClientOptions blobOptions;
+    for (const auto& p : options.PerOperationPolicies)
+    {
+      blobOptions.PerOperationPolicies.emplace_back(p->Clone());
+    }
+    for (const auto& p : options.PerRetryPolicies)
+    {
+      blobOptions.PerRetryPolicies.emplace_back(p->Clone());
+    }
+    blobOptions.RetryOptions = options.RetryOptions;
+    blobOptions.RetryOptions.SecondaryHostForRetryReads
+        = Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
+    blobOptions.TransportPolicyOptions = options.TransportPolicyOptions;
+    blobOptions.ApplicationId = options.ApplicationId;
+    blobOptions.ApiVersion = options.ApiVersion;
+    return blobOptions;
+  }
+
 }}}}} // namespace Azure::Storage::Files::DataLake::Details
diff --git a/sdk/storage/azure-storage-files-datalake/test/datalake_directory_client_test.cpp b/sdk/storage/azure-storage-files-datalake/test/datalake_directory_client_test.cpp
index 7faa49f4b..d99e8af4c 100644
--- a/sdk/storage/azure-storage-files-datalake/test/datalake_directory_client_test.cpp
+++ b/sdk/storage/azure-storage-files-datalake/test/datalake_directory_client_test.cpp
@@ -8,6 +8,7 @@
 
 #include <azure/identity/client_secret_credential.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
+#include <azure/storage/files/datalake/datalake_utilities.hpp>
 
 namespace Azure { namespace Storage { namespace Test {
 
@@ -614,9 +615,10 @@ namespace Azure { namespace Storage { namespace Test {
           AadTenantId(), AadClientId(), AadClientSecret());
 
       auto clientSecretClient = Azure::Storage::Files::DataLake::DataLakeDirectoryClient(
-          Azure::Storage::Files::DataLake::DataLakeDirectoryClient::CreateFromConnectionString(
-              AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
-              .GetUrl(),
+          Azure::Storage::Files::DataLake::Details::GetDfsUrlFromUrl(
+              Azure::Storage::Files::DataLake::DataLakeDirectoryClient::CreateFromConnectionString(
+                  AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
+                  .GetUrl()),
           credential);
 
       EXPECT_NO_THROW(clientSecretClient.Create());
diff --git a/sdk/storage/azure-storage-files-datalake/test/datalake_file_client_test.cpp b/sdk/storage/azure-storage-files-datalake/test/datalake_file_client_test.cpp
index fb49a35c0..a6976c8d7 100644
--- a/sdk/storage/azure-storage-files-datalake/test/datalake_file_client_test.cpp
+++ b/sdk/storage/azure-storage-files-datalake/test/datalake_file_client_test.cpp
@@ -13,6 +13,7 @@
 #include <azure/storage/blobs.hpp>
 #include <azure/storage/common/file_io.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
+#include <azure/storage/files/datalake/datalake_utilities.hpp>
 
 namespace Azure { namespace Storage { namespace Files { namespace DataLake { namespace Models {
 
@@ -563,9 +564,10 @@ namespace Azure { namespace Storage { namespace Test {
           AadTenantId(), AadClientId(), AadClientSecret());
 
       auto clientSecretClient = Azure::Storage::Files::DataLake::DataLakeFileClient(
-          Azure::Storage::Files::DataLake::DataLakeFileClient::CreateFromConnectionString(
-              AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
-              .GetUrl(),
+          Azure::Storage::Files::DataLake::Details::GetDfsUrlFromUrl(
+              Azure::Storage::Files::DataLake::DataLakeFileClient::CreateFromConnectionString(
+                  AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
+                  .GetUrl()),
           credential);
 
       EXPECT_NO_THROW(clientSecretClient.Create());
diff --git a/sdk/storage/azure-storage-files-datalake/test/datalake_path_client_test.cpp b/sdk/storage/azure-storage-files-datalake/test/datalake_path_client_test.cpp
index a3968d9e6..0a15058b8 100644
--- a/sdk/storage/azure-storage-files-datalake/test/datalake_path_client_test.cpp
+++ b/sdk/storage/azure-storage-files-datalake/test/datalake_path_client_test.cpp
@@ -7,6 +7,7 @@
 #include <thread>
 
 #include <azure/identity/client_secret_credential.hpp>
+#include <azure/storage/files/datalake/datalake_utilities.hpp>
 
 namespace Azure { namespace Storage { namespace Test {
 
@@ -364,9 +365,10 @@ namespace Azure { namespace Storage { namespace Test {
           AadTenantId(), AadClientId(), AadClientSecret());
 
       auto clientSecretClient = Azure::Storage::Files::DataLake::DataLakePathClient(
-          Azure::Storage::Files::DataLake::DataLakePathClient::CreateFromConnectionString(
-              AdlsGen2ConnectionString(), m_fileSystemName, LowercaseRandomString(10))
-              .GetUrl(),
+          Files::DataLake::Details::GetDfsUrlFromUrl(
+              Azure::Storage::Files::DataLake::DataLakePathClient::CreateFromConnectionString(
+                  AdlsGen2ConnectionString(), m_fileSystemName, LowercaseRandomString(10))
+                  .GetUrl()),
           credential);
 
       EXPECT_NO_THROW(clientSecretClient.Create(Files::DataLake::Models::PathResourceType::File));
diff --git a/sdk/storage/azure-storage-files-datalake/test/datalake_sas_test.cpp b/sdk/storage/azure-storage-files-datalake/test/datalake_sas_test.cpp
index af8b4393e..c47024ae6 100644
--- a/sdk/storage/azure-storage-files-datalake/test/datalake_sas_test.cpp
+++ b/sdk/storage/azure-storage-files-datalake/test/datalake_sas_test.cpp
@@ -56,7 +56,7 @@ namespace Azure { namespace Storage { namespace Test {
     auto filesystemUrl = Files::DataLake::Details::GetDfsUrlFromUrl(filesystemClient0.GetUrl());
     auto directory1Url = Files::DataLake::Details::GetDfsUrlFromUrl(directory1Client0.GetUrl());
     auto directory2Url = Files::DataLake::Details::GetDfsUrlFromUrl(directory2Client0.GetUrl());
-    auto fileUrl = fileClient0.GetUrl();
+    auto fileUrl = Files::DataLake::Details::GetDfsUrlFromUrl(fileClient0.GetUrl());
 
     auto serviceClient1 = Files::DataLake::DataLakeServiceClient(
         serviceUrl,
diff --git a/sdk/storage/azure-storage-files-shares/CHANGELOG.md b/sdk/storage/azure-storage-files-shares/CHANGELOG.md
index ffad107ca..60d201146 100644
--- a/sdk/storage/azure-storage-files-shares/CHANGELOG.md
+++ b/sdk/storage/azure-storage-files-shares/CHANGELOG.md
@@ -2,6 +2,9 @@
 
 ## 12.0.0-beta.9 (Unreleased)
 
+### New Features
+
+- Added support for customized application ID.
 
 ## 12.0.0-beta.8 (2021-02-12)
 
diff --git a/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/share_options.hpp b/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/share_options.hpp
index b7d731fda..2a6a92b25 100644
--- a/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/share_options.hpp
+++ b/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/share_options.hpp
@@ -43,6 +43,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
      * @brief Customized HTTP client. We're going to use the default one if this is empty.
      */
     Azure::Core::Http::TransportPolicyOptions TransportPolicyOptions;
+
+    /**
+     * @brief The last part of the user agent for telemetry.
+     */
+    std::string ApplicationId;
+
+    /**
+     * API version used by this client.
+     */
+    std::string ApiVersion = Details::DefaultServiceApiVersion;
   };
 
   struct ListSharesSinglePageOptions
diff --git a/sdk/storage/azure-storage-files-shares/src/share_client.cpp b/sdk/storage/azure-storage-files-shares/src/share_client.cpp
index 7e0c28dda..94aa5a8d7 100644
--- a/sdk/storage/azure-storage-files-shares/src/share_client.cpp
+++ b/sdk/storage/azure-storage-files-shares/src/share_client.cpp
@@ -9,8 +9,6 @@
 #include <azure/storage/common/crypt.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/shares/share_directory_client.hpp"
 #include "azure/storage/files/shares/share_file_client.hpp"
@@ -43,49 +41,31 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       const ShareClientOptions& options)
       : m_shareUrl(shareUrl)
   {
-
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   ShareClient::ShareClient(const std::string& shareUrl, const ShareClientOptions& options)
       : m_shareUrl(shareUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   ShareDirectoryClient ShareClient::GetRootDirectoryClient() const
diff --git a/sdk/storage/azure-storage-files-shares/src/share_directory_client.cpp b/sdk/storage/azure-storage-files-shares/src/share_directory_client.cpp
index 4e50c22f5..5d7bc4a5c 100644
--- a/sdk/storage/azure-storage-files-shares/src/share_directory_client.cpp
+++ b/sdk/storage/azure-storage-files-shares/src/share_directory_client.cpp
@@ -9,8 +9,6 @@
 #include <azure/storage/common/crypt.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/shares/share_file_client.hpp"
 #include "azure/storage/files/shares/version.hpp"
@@ -45,25 +43,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       const ShareClientOptions& options)
       : m_shareDirectoryUrl(shareDirectoryUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   ShareDirectoryClient::ShareDirectoryClient(
@@ -71,24 +60,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       const ShareClientOptions& options)
       : m_shareDirectoryUrl(shareDirectoryUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   ShareDirectoryClient ShareDirectoryClient::GetSubdirectoryClient(
diff --git a/sdk/storage/azure-storage-files-shares/src/share_file_client.cpp b/sdk/storage/azure-storage-files-shares/src/share_file_client.cpp
index 37f721065..07544bbaf 100644
--- a/sdk/storage/azure-storage-files-shares/src/share_file_client.cpp
+++ b/sdk/storage/azure-storage-files-shares/src/share_file_client.cpp
@@ -12,8 +12,6 @@
 #include <azure/storage/common/reliable_stream.hpp>
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/shares/share_constants.hpp"
 #include "azure/storage/files/shares/version.hpp"
@@ -48,26 +46,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       const ShareClientOptions& options)
       : m_shareFileUrl(shareFileUrl)
   {
-
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   ShareFileClient::ShareFileClient(
@@ -75,23 +63,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       const ShareClientOptions& options)
       : m_shareFileUrl(shareFileUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   ShareFileClient ShareFileClient::WithShareSnapshot(const std::string& shareSnapshot) const
diff --git a/sdk/storage/azure-storage-files-shares/src/share_service_client.cpp b/sdk/storage/azure-storage-files-shares/src/share_service_client.cpp
index b24eef653..908e11700 100644
--- a/sdk/storage/azure-storage-files-shares/src/share_service_client.cpp
+++ b/sdk/storage/azure-storage-files-shares/src/share_service_client.cpp
@@ -9,8 +9,6 @@
 #include <azure/storage/common/shared_key_policy.hpp>
 #include <azure/storage/common/storage_common.hpp>
 #include <azure/storage/common/storage_credential.hpp>
-#include <azure/storage/common/storage_per_retry_policy.hpp>
-#include <azure/storage/common/storage_retry_policy.hpp>
 
 #include "azure/storage/files/shares/share_client.hpp"
 #include "azure/storage/files/shares/version.hpp"
@@ -40,25 +38,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       const ShareClientOptions& options)
       : m_serviceUrl(serviceUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(
-        std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
+            options));
   }
 
   ShareServiceClient::ShareServiceClient(
@@ -66,23 +55,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       const ShareClientOptions& options)
       : m_serviceUrl(serviceUrl)
   {
-    std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
-    policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
-        Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
-    policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
-    for (const auto& p : options.PerOperationPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    for (const auto& p : options.PerRetryPolicies)
-    {
-      policies.emplace_back(p->Clone());
-    }
-    policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
-    policies.emplace_back(
-        std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
-    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
+    Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
+    telemetryPolicyOptions.ApplicationId = options.ApplicationId;
+    m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
+        Storage::Details::ConstructPolicies(
+            std::make_unique<Azure::Core::Http::TelemetryPolicy>(
+                Storage::Details::BlobServicePackageName,
+                Details::Version::VersionString(),
+                telemetryPolicyOptions),
+            nullptr,
+            options));
   }
 
   ShareClient ShareServiceClient::GetShareClient(const std::string& shareName) const