@azure/storage-blob 12.13.0-alpha.20230202.2 → 12.13.0

package/dist-esm/storage-blob/src/Clients.js

@@ -1,12 +1,11 @@
 import { __asyncDelegator, __asyncGenerator, __asyncValues, __await } from "tslib";
-import { getDefaultProxySettings, } from "@azure/core-rest-pipeline";
-import { isTokenCredential } from "@azure/core-auth";
-import { isNode } from "@azure/core-util";
-import { v4 as generateUuid } from "uuid";
+import { generateUuid, getDefaultProxySettings, isNode, isTokenCredential, URLBuilder, } from "@azure/core-http";
+import { SpanStatusCode } from "@azure/core-tracing";
 import { BlobDownloadResponse } from "./BlobDownloadResponse";
 import { BlobQueryResponse } from "./BlobQueryResponse";
 import { AnonymousCredential } from "./credentials/AnonymousCredential";
 import { StorageSharedKeyCredential } from "./credentials/StorageSharedKeyCredential";
+import { AppendBlob, Blob as StorageBlob, BlockBlob, PageBlob } from "./generated/src/operations";
 import { ensureCpkIfSpecified, toAccessTier, } from "./models";
 import { rangeResponseFromModel, } from "./PageBlobRangeResponse";
 import { newPipeline, isPipelineLike } from "./Pipeline";
@@ -16,8 +15,8 @@ import { StorageClient } from "./StorageClient";
 import { Batch } from "./utils/Batch";
 import { BufferScheduler } from "../../storage-common/src";
 import { BlobDoesNotUseCustomerSpecifiedEncryption, BlobUsesCustomerSpecifiedEncryptionMsg, BLOCK_BLOB_MAX_BLOCKS, BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES, BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES, DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES, DEFAULT_BLOCK_BUFFER_SIZE_BYTES, DEFAULT_MAX_DOWNLOAD_RETRY_REQUESTS, ETagAny, URLConstants, } from "./utils/constants";
-import { tracingClient } from "./utils/tracing";
-import { appendToURLPath, appendToURLQuery, assertResponse, extractConnectionStringParts, ExtractPageRangeInfoItems, generateBlockID, getURLParameter, httpAuthorizationToString, isIpEndpointStyle, parseObjectReplicationRecord, setURLParameter, toBlobTags, toBlobTagsString, toQuerySerialization, toTags, } from "./utils/utils.common";
+import { createSpan, convertTracingToRequestOptionsBase } from "./utils/tracing";
+import { appendToURLPath, appendToURLQuery, extractConnectionStringParts, ExtractPageRangeInfoItems, generateBlockID, getURLParameter, httpAuthorizationToString, isIpEndpointStyle, parseObjectReplicationRecord, setURLParameter, toBlobTags, toBlobTagsString, toQuerySerialization, toTags, } from "./utils/utils.common";
 import { fsCreateReadStream, fsStat, readStreamToLocalFile, streamToBuffer, } from "./utils/utils.node";
 import { generateBlobSASQueryParameters } from "./sas/BlobSASSignatureValues";
 import { BlobLeaseClient } from "./BlobLeaseClient";
@@ -91,7 +90,7 @@ export class BlobClient extends StorageClient {
         super(url, pipeline);
         ({ blobName: this._name, containerName: this._containerName } =
             this.getBlobAndContainerNamesFromUrl());
-        this.blobContext = this.storageClientContext.blob;
+        this.blobContext = new StorageBlob(this.storageClientContext);
         this._snapshot = getURLParameter(this.url, URLConstants.Parameters.SNAPSHOT);
         this._versionId = getURLParameter(this.url, URLConstants.Parameters.VERSIONID);
     }
@@ -208,25 +207,15 @@ export class BlobClient extends StorageClient {
      * ```
      */
     async download(offset = 0, count, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
         options.conditions = options.conditions || {};
         ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlobClient-download", options, async (updatedOptions) => {
-            var _a;
-            const res = assertResponse(await this.blobContext.download({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                requestOptions: {
+        const { span, updatedOptions } = createSpan("BlobClient-download", options);
+        try {
+            const res = await this.blobContext.download(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), requestOptions: {
                     onDownloadProgress: isNode ? undefined : options.onProgress, // for Node.js, progress is reported by RetriableReadableStream
-                },
-                range: offset === 0 && !count ? undefined : rangeToString({ offset, count }),
-                rangeGetContentMD5: options.rangeGetContentMD5,
-                rangeGetContentCRC64: options.rangeGetContentCrc64,
-                snapshot: options.snapshot,
-                cpkInfo: options.customerProvidedKey,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
+                }, range: offset === 0 && !count ? undefined : rangeToString({ offset, count }), rangeGetContentMD5: options.rangeGetContentMD5, rangeGetContentCRC64: options.rangeGetContentCrc64, snapshot: options.snapshot, cpkInfo: options.customerProvidedKey }, convertTracingToRequestOptionsBase(updatedOptions)));
             const wrappedRes = Object.assign(Object.assign({}, res), { _response: res._response, objectReplicationDestinationPolicyId: res.objectReplicationPolicyId, objectReplicationSourceProperties: parseObjectReplicationRecord(res.objectReplicationRules) });
             // Return browser response immediately
             if (!isNode) {
@@ -278,7 +267,17 @@ export class BlobClient extends StorageClient {
                 maxRetryRequests: options.maxRetryRequests,
                 onProgress: options.onProgress,
             });
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns true if the Azure blob resource represented by this client exists; false otherwise.
@@ -290,31 +289,37 @@ export class BlobClient extends StorageClient {
      * @param options - options to Exists operation.
      */
     async exists(options = {}) {
-        return tracingClient.withSpan("BlobClient-exists", options, async (updatedOptions) => {
-            try {
-                ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-                await this.getProperties({
-                    abortSignal: options.abortSignal,
-                    customerProvidedKey: options.customerProvidedKey,
-                    conditions: options.conditions,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-                return true;
+        const { span, updatedOptions } = createSpan("BlobClient-exists", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            await this.getProperties({
+                abortSignal: options.abortSignal,
+                customerProvidedKey: options.customerProvidedKey,
+                conditions: options.conditions,
+                tracingOptions: updatedOptions.tracingOptions,
+            });
+            return true;
+        }
+        catch (e) {
+            if (e.statusCode === 404) {
+                // Expected exception when checking blob existence
+                return false;
             }
-            catch (e) {
-                if (e.statusCode === 404) {
-                    // Expected exception when checking blob existence
-                    return false;
-                }
-                else if (e.statusCode === 409 &&
-                    (e.details.errorCode === BlobUsesCustomerSpecifiedEncryptionMsg ||
-                        e.details.errorCode === BlobDoesNotUseCustomerSpecifiedEncryption)) {
-                    // Expected exception when checking blob existence
-                    return true;
-                }
-                throw e;
+            else if (e.statusCode === 409 &&
+                (e.details.errorCode === BlobUsesCustomerSpecifiedEncryptionMsg ||
+                    e.details.errorCode === BlobDoesNotUseCustomerSpecifiedEncryption)) {
+                // Expected exception when checking blob existence
+                return true;
             }
-        });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns all user-defined metadata, standard HTTP properties, and system properties
@@ -329,19 +334,24 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to Get Properties operation.
      */
     async getProperties(options = {}) {
-        options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlobClient-getProperties", options, async (updatedOptions) => {
-            var _a;
-            const res = assertResponse(await this.blobContext.getProperties({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                cpkInfo: options.customerProvidedKey,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-getProperties", options);
+        try {
+            options.conditions = options.conditions || {};
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            const res = await this.blobContext.getProperties(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), cpkInfo: options.customerProvidedKey }, convertTracingToRequestOptionsBase(updatedOptions)));
             return Object.assign(Object.assign({}, res), { _response: res._response, objectReplicationDestinationPolicyId: res.objectReplicationPolicyId, objectReplicationSourceProperties: parseObjectReplicationRecord(res.objectReplicationRules) });
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Marks the specified blob or snapshot for deletion. The blob is later deleted
@@ -353,17 +363,22 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to Blob Delete operation.
      */
     async delete(options = {}) {
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-delete", options);
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("BlobClient-delete", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.blobContext.delete({
-                abortSignal: options.abortSignal,
-                deleteSnapshots: options.deleteSnapshots,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            return await this.blobContext.delete(Object.assign({ abortSignal: options.abortSignal, deleteSnapshots: options.deleteSnapshots, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Marks the specified blob or snapshot for deletion if it exists. The blob is later deleted
@@ -375,19 +390,29 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to Blob Delete operation.
      */
     async deleteIfExists(options = {}) {
-        return tracingClient.withSpan("BlobClient-deleteIfExists", options, async (updatedOptions) => {
-            var _a, _b;
-            try {
-                const res = assertResponse(await this.delete(updatedOptions));
-                return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
-            }
-            catch (e) {
-                if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "BlobNotFound") {
-                    return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
-                }
-                throw e;
+        var _a, _b;
+        const { span, updatedOptions } = createSpan("BlobClient-deleteIfExists", options);
+        try {
+            const res = await this.delete(updatedOptions);
+            return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
+        }
+        catch (e) {
+            if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "BlobNotFound") {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: "Expected exception when deleting a blob or snapshot only if it exists.",
+                });
+                return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
             }
-        });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Restores the contents and metadata of soft deleted blob and any associated
@@ -398,12 +423,20 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to Blob Undelete operation.
      */
     async undelete(options = {}) {
-        return tracingClient.withSpan("BlobClient-undelete", options, async (updatedOptions) => {
-            return assertResponse(await this.blobContext.undelete({
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("BlobClient-undelete", options);
+        try {
+            return await this.blobContext.undelete(Object.assign({ abortSignal: options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Sets system properties on the blob.
@@ -421,19 +454,23 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to Blob Set HTTP Headers operation.
      */
     async setHTTPHeaders(blobHTTPHeaders, options = {}) {
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-setHTTPHeaders", options);
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlobClient-setHTTPHeaders", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.blobContext.setHttpHeaders({
-                abortSignal: options.abortSignal,
-                blobHttpHeaders: blobHTTPHeaders,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                // cpkInfo: options.customerProvidedKey, // CPK is not included in Swagger, should change this back when this issue is fixed in Swagger.
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blobContext.setHttpHeaders(Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: blobHTTPHeaders, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Sets user-defined metadata for the specified blob as one or more name-value pairs.
@@ -447,20 +484,23 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to Set Metadata operation.
      */
     async setMetadata(metadata, options = {}) {
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-setMetadata", options);
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlobClient-setMetadata", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.blobContext.setMetadata({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                metadata,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blobContext.setMetadata(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Sets tags on the underlying blob.
@@ -472,16 +512,21 @@ export class BlobClient extends StorageClient {
      * @param options -
      */
     async setTags(tags, options = {}) {
-        return tracingClient.withSpan("BlobClient-setTags", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.blobContext.setTags({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                tracingOptions: updatedOptions.tracingOptions,
-                tags: toBlobTags(tags),
-            }));
-        });
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-setTags", options);
+        try {
+            return await this.blobContext.setTags(Object.assign(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)), { tags: toBlobTags(tags) }));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Gets the tags associated with the underlying blob.
@@ -489,17 +534,23 @@ export class BlobClient extends StorageClient {
      * @param options -
      */
     async getTags(options = {}) {
-        return tracingClient.withSpan("BlobClient-getTags", options, async (updatedOptions) => {
-            var _a;
-            const response = assertResponse(await this.blobContext.getTags({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-getTags", options);
+        try {
+            const response = await this.blobContext.getTags(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
             const wrappedResponse = Object.assign(Object.assign({}, response), { _response: response._response, tags: toTags({ blobTagSet: response.blobTagSet }) || {} });
             return wrappedResponse;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Get a {@link BlobLeaseClient} that manages leases on the blob.
@@ -517,20 +568,23 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to the Blob Create Snapshot operation.
      */
     async createSnapshot(options = {}) {
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-createSnapshot", options);
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlobClient-createSnapshot", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.blobContext.createSnapshot({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                metadata: options.metadata,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blobContext.createSnapshot(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Asynchronously copies a blob to a destination within the storage account.
@@ -632,13 +686,20 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to the Blob Abort Copy From URL operation.
      */
     async abortCopyFromURL(copyId, options = {}) {
-        return tracingClient.withSpan("BlobClient-abortCopyFromURL", options, async (updatedOptions) => {
-            return assertResponse(await this.blobContext.abortCopyFromURL(copyId, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("BlobClient-abortCopyFromURL", options);
+        try {
+            return await this.blobContext.abortCopyFromURL(copyId, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * The synchronous Copy From URL operation copies a blob or an internet resource to a new blob. It will not
@@ -649,33 +710,28 @@ export class BlobClient extends StorageClient {
      * @param options -
      */
     async syncCopyFromURL(copySource, options = {}) {
+        var _a, _b, _c;
+        const { span, updatedOptions } = createSpan("BlobClient-syncCopyFromURL", options);
         options.conditions = options.conditions || {};
         options.sourceConditions = options.sourceConditions || {};
-        return tracingClient.withSpan("BlobClient-syncCopyFromURL", options, async (updatedOptions) => {
-            var _a, _b, _c, _d, _e, _f, _g;
-            return assertResponse(await this.blobContext.copyFromURL(copySource, {
-                abortSignal: options.abortSignal,
-                metadata: options.metadata,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                sourceModifiedAccessConditions: {
-                    sourceIfMatch: (_b = options.sourceConditions) === null || _b === void 0 ? void 0 : _b.ifMatch,
-                    sourceIfModifiedSince: (_c = options.sourceConditions) === null || _c === void 0 ? void 0 : _c.ifModifiedSince,
-                    sourceIfNoneMatch: (_d = options.sourceConditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch,
-                    sourceIfUnmodifiedSince: (_e = options.sourceConditions) === null || _e === void 0 ? void 0 : _e.ifUnmodifiedSince,
-                },
-                sourceContentMD5: options.sourceContentMD5,
-                copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
-                tier: toAccessTier(options.tier),
-                blobTagsString: toBlobTagsString(options.tags),
-                immutabilityPolicyExpiry: (_f = options.immutabilityPolicy) === null || _f === void 0 ? void 0 : _f.expiriesOn,
-                immutabilityPolicyMode: (_g = options.immutabilityPolicy) === null || _g === void 0 ? void 0 : _g.policyMode,
-                legalHold: options.legalHold,
-                encryptionScope: options.encryptionScope,
-                copySourceTags: options.copySourceTags,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            return await this.blobContext.copyFromURL(copySource, Object.assign({ abortSignal: options.abortSignal, metadata: options.metadata, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), sourceModifiedAccessConditions: {
+                    sourceIfMatch: options.sourceConditions.ifMatch,
+                    sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
+                    sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
+                    sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince,
+                }, sourceContentMD5: options.sourceContentMD5, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization), tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags), immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode, legalHold: options.legalHold, encryptionScope: options.encryptionScope, copySourceTags: options.copySourceTags }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Sets the tier on a blob. The operation is allowed on a page blob in a premium
@@ -689,19 +745,23 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to the Blob Set Tier operation.
      */
     async setAccessTier(tier, options = {}) {
-        return tracingClient.withSpan("BlobClient-setAccessTier", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.blobContext.setTier(toAccessTier(tier), {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                rehydratePriority: options.rehydratePriority,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        var _a;
+        const { span, updatedOptions } = createSpan("BlobClient-setAccessTier", options);
+        try {
+            return await this.blobContext.setTier(toAccessTier(tier), Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), rehydratePriority: options.rehydratePriority }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     async downloadToBuffer(param1, param2, param3, param4 = {}) {
-        var _a;
         let buffer;
         let offset = 0;
         let count = 0;
@@ -716,26 +776,29 @@ export class BlobClient extends StorageClient {
             count = typeof param2 === "number" ? param2 : 0;
             options = param3 || {};
         }
-        let blockSize = (_a = options.blockSize) !== null && _a !== void 0 ? _a : 0;
-        if (blockSize < 0) {
-            throw new RangeError("blockSize option must be >= 0");
-        }
-        if (blockSize === 0) {
-            blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
-        }
-        if (offset < 0) {
-            throw new RangeError("offset option must be >= 0");
-        }
-        if (count && count <= 0) {
-            throw new RangeError("count option must be greater than 0");
-        }
-        if (!options.conditions) {
-            options.conditions = {};
-        }
-        return tracingClient.withSpan("BlobClient-downloadToBuffer", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("BlobClient-downloadToBuffer", options);
+        try {
+            if (!options.blockSize) {
+                options.blockSize = 0;
+            }
+            if (options.blockSize < 0) {
+                throw new RangeError("blockSize option must be >= 0");
+            }
+            if (options.blockSize === 0) {
+                options.blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
+            }
+            if (offset < 0) {
+                throw new RangeError("offset option must be >= 0");
+            }
+            if (count && count <= 0) {
+                throw new RangeError("count option must be greater than 0");
+            }
+            if (!options.conditions) {
+                options.conditions = {};
+            }
             // Customer doesn't specify length, get it
             if (!count) {
-                const response = await this.getProperties(Object.assign(Object.assign({}, options), { tracingOptions: updatedOptions.tracingOptions }));
+                const response = await this.getProperties(Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
                 count = response.contentLength - offset;
                 if (count < 0) {
                     throw new RangeError(`offset ${offset} shouldn't be larger than blob size ${response.contentLength}`);
@@ -755,19 +818,19 @@ export class BlobClient extends StorageClient {
             }
             let transferProgress = 0;
             const batch = new Batch(options.concurrency);
-            for (let off = offset; off < offset + count; off = off + blockSize) {
+            for (let off = offset; off < offset + count; off = off + options.blockSize) {
                 batch.addOperation(async () => {
                     // Exclusive chunk end position
                     let chunkEnd = offset + count;
-                    if (off + blockSize < chunkEnd) {
-                        chunkEnd = off + blockSize;
+                    if (off + options.blockSize < chunkEnd) {
+                        chunkEnd = off + options.blockSize;
                     }
                     const response = await this.download(off, chunkEnd - off, {
                         abortSignal: options.abortSignal,
                         conditions: options.conditions,
                         maxRetryRequests: options.maxRetryRequestsPerBlock,
                         customerProvidedKey: options.customerProvidedKey,
-                        tracingOptions: updatedOptions.tracingOptions,
+                        tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)),
                     });
                     const stream = response.readableStreamBody;
                     await streamToBuffer(stream, buffer, off - offset, chunkEnd - offset);
@@ -782,7 +845,17 @@ export class BlobClient extends StorageClient {
             }
             await batch.do();
             return buffer;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * ONLY AVAILABLE IN NODE.JS RUNTIME.
@@ -801,15 +874,26 @@ export class BlobClient extends StorageClient {
      *                                                 at the specified path.
      */
     async downloadToFile(filePath, offset = 0, count, options = {}) {
-        return tracingClient.withSpan("BlobClient-downloadToFile", options, async (updatedOptions) => {
-            const response = await this.download(offset, count, Object.assign(Object.assign({}, options), { tracingOptions: updatedOptions.tracingOptions }));
+        const { span, updatedOptions } = createSpan("BlobClient-downloadToFile", options);
+        try {
+            const response = await this.download(offset, count, Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
             if (response.readableStreamBody) {
                 await readStreamToLocalFile(response.readableStreamBody, filePath);
             }
             // The stream is no longer accessible so setting it to undefined.
             response.blobDownloadStream = undefined;
             return response;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     getBlobAndContainerNamesFromUrl() {
         let containerName;
@@ -822,11 +906,11 @@ export class BlobClient extends StorageClient {
             // "https://myaccount.blob.core.windows.net/mycontainer/blob/a.txt";
             // IPv4/IPv6 address hosts, Endpoints - `http://127.0.0.1:10000/devstoreaccount1/containername/blob`
             // http://localhost:10001/devstoreaccount1/containername/blob
-            const parsedUrl = new URL(this.url);
-            if (parsedUrl.host.split(".")[1] === "blob") {
+            const parsedUrl = URLBuilder.parse(this.url);
+            if (parsedUrl.getHost().split(".")[1] === "blob") {
                 // "https://myaccount.blob.core.windows.net/containername/blob".
                 // .getPath() -> /containername/blob
-                const pathComponents = parsedUrl.pathname.match("/([^/]*)(/(.*))?");
+                const pathComponents = parsedUrl.getPath().match("/([^/]*)(/(.*))?");
                 containerName = pathComponents[1];
                 blobName = pathComponents[3];
             }
@@ -834,14 +918,14 @@ export class BlobClient extends StorageClient {
                 // IPv4/IPv6 address hosts... Example - http://192.0.0.10:10001/devstoreaccount1/containername/blob
                 // Single word domain without a [dot] in the endpoint... Example - http://localhost:10001/devstoreaccount1/containername/blob
                 // .getPath() -> /devstoreaccount1/containername/blob
-                const pathComponents = parsedUrl.pathname.match("/([^/]*)/([^/]*)(/(.*))?");
+                const pathComponents = parsedUrl.getPath().match("/([^/]*)/([^/]*)(/(.*))?");
                 containerName = pathComponents[2];
                 blobName = pathComponents[4];
             }
             else {
                 // "https://customdomain.com/containername/blob".
                 // .getPath() -> /containername/blob
-                const pathComponents = parsedUrl.pathname.match("/([^/]*)(/(.*))?");
+                const pathComponents = parsedUrl.getPath().match("/([^/]*)(/(.*))?");
                 containerName = pathComponents[1];
                 blobName = pathComponents[3];
             }
@@ -874,32 +958,29 @@ export class BlobClient extends StorageClient {
      * @param options - Optional options to the Blob Start Copy From URL operation.
      */
     async startCopyFromURL(copySource, options = {}) {
-        return tracingClient.withSpan("BlobClient-startCopyFromURL", options, async (updatedOptions) => {
-            var _a, _b, _c;
-            options.conditions = options.conditions || {};
-            options.sourceConditions = options.sourceConditions || {};
-            return assertResponse(await this.blobContext.startCopyFromURL(copySource, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                metadata: options.metadata,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                sourceModifiedAccessConditions: {
+        var _a, _b, _c;
+        const { span, updatedOptions } = createSpan("BlobClient-startCopyFromURL", options);
+        options.conditions = options.conditions || {};
+        options.sourceConditions = options.sourceConditions || {};
+        try {
+            return await this.blobContext.startCopyFromURL(copySource, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), sourceModifiedAccessConditions: {
                     sourceIfMatch: options.sourceConditions.ifMatch,
                     sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
                     sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
                     sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince,
                     sourceIfTags: options.sourceConditions.tagConditions,
-                },
-                immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn,
-                immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode,
-                legalHold: options.legalHold,
-                rehydratePriority: options.rehydratePriority,
-                tier: toAccessTier(options.tier),
-                blobTagsString: toBlobTagsString(options.tags),
-                sealBlob: options.sealBlob,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+                }, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode, legalHold: options.legalHold, rehydratePriority: options.rehydratePriority, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags), sealBlob: options.sealBlob }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Only available for BlobClient constructed with a shared key credential.
@@ -926,38 +1007,63 @@ export class BlobClient extends StorageClient {
      *
      * @param options - Optional options to delete immutability policy on the blob.
      */
-    async deleteImmutabilityPolicy(options = {}) {
-        return tracingClient.withSpan("BlobClient-deleteImmutabilityPolicy", options, async (updatedOptions) => {
-            return assertResponse(await this.blobContext.deleteImmutabilityPolicy({
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+    async deleteImmutabilityPolicy(options) {
+        const { span, updatedOptions } = createSpan("BlobClient-deleteImmutabilityPolicy", options);
+        try {
+            return await this.blobContext.deleteImmutabilityPolicy(Object.assign({ abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
-     * Set immutability policy on the blob.
+     * Set immutablility policy on the blob.
      *
      * @param options - Optional options to set immutability policy on the blob.
      */
-    async setImmutabilityPolicy(immutabilityPolicy, options = {}) {
-        return tracingClient.withSpan("BlobClient-setImmutabilityPolicy", options, async (updatedOptions) => {
-            return assertResponse(await this.blobContext.setImmutabilityPolicy({
-                immutabilityPolicyExpiry: immutabilityPolicy.expiriesOn,
-                immutabilityPolicyMode: immutabilityPolicy.policyMode,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+    async setImmutabilityPolicy(immutabilityPolicy, options) {
+        const { span, updatedOptions } = createSpan("BlobClient-setImmutabilityPolicy", options);
+        try {
+            return await this.blobContext.setImmutabilityPolicy(Object.assign({ abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal, immutabilityPolicyExpiry: immutabilityPolicy.expiriesOn, immutabilityPolicyMode: immutabilityPolicy.policyMode, modifiedAccessConditions: options === null || options === void 0 ? void 0 : options.modifiedAccessCondition }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Set legal hold on the blob.
      *
      * @param options - Optional options to set legal hold on the blob.
      */
-    async setLegalHold(legalHoldEnabled, options = {}) {
-        return tracingClient.withSpan("BlobClient-setLegalHold", options, async (updatedOptions) => {
-            return assertResponse(await this.blobContext.setLegalHold(legalHoldEnabled, {
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+    async setLegalHold(legalHoldEnabled, options) {
+        const { span, updatedOptions } = createSpan("BlobClient-setLegalHold", options);
+        try {
+            return await this.blobContext.setLegalHold(legalHoldEnabled, Object.assign({ abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
 }
 /**
@@ -1029,7 +1135,7 @@ export class AppendBlobClient extends BlobClient {
             throw new Error("Expecting non-empty strings for containerName and blobName parameters");
         }
         super(url, pipeline);
-        this.appendBlobContext = this.storageClientContext.appendBlob;
+        this.appendBlobContext = new AppendBlob(this.storageClientContext);
     }
     /**
      * Creates a new AppendBlobClient object identical to the source but with the
@@ -1057,25 +1163,23 @@ export class AppendBlobClient extends BlobClient {
      * ```
      */
     async create(options = {}) {
+        var _a, _b, _c;
+        const { span, updatedOptions } = createSpan("AppendBlobClient-create", options);
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("AppendBlobClient-create", options, async (updatedOptions) => {
-            var _a, _b, _c;
-            return assertResponse(await this.appendBlobContext.create(0, {
-                abortSignal: options.abortSignal,
-                blobHttpHeaders: options.blobHTTPHeaders,
-                leaseAccessConditions: options.conditions,
-                metadata: options.metadata,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn,
-                immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode,
-                legalHold: options.legalHold,
-                blobTagsString: toBlobTagsString(options.tags),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.appendBlobContext.create(0, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode, legalHold: options.legalHold, blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Creates a 0-length append blob. Call AppendBlock to append data to an append blob.
@@ -1085,20 +1189,30 @@ export class AppendBlobClient extends BlobClient {
      * @param options -
      */
     async createIfNotExists(options = {}) {
+        var _a, _b;
+        const { span, updatedOptions } = createSpan("AppendBlobClient-createIfNotExists", options);
         const conditions = { ifNoneMatch: ETagAny };
-        return tracingClient.withSpan("AppendBlobClient-createIfNotExists", options, async (updatedOptions) => {
-            var _a, _b;
-            try {
-                const res = assertResponse(await this.create(Object.assign(Object.assign({}, updatedOptions), { conditions })));
-                return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
-            }
-            catch (e) {
-                if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "BlobAlreadyExists") {
-                    return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
-                }
-                throw e;
+        try {
+            const res = await this.create(Object.assign(Object.assign({}, updatedOptions), { conditions }));
+            return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
+        }
+        catch (e) {
+            if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "BlobAlreadyExists") {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: "Expected exception when creating a blob only if it does not already exist.",
+                });
+                return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
             }
-        });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Seals the append blob, making it read only.
@@ -1106,17 +1220,22 @@ export class AppendBlobClient extends BlobClient {
      * @param options -
      */
     async seal(options = {}) {
+        var _a;
+        const { span, updatedOptions } = createSpan("AppendBlobClient-seal", options);
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("AppendBlobClient-seal", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.appendBlobContext.seal({
-                abortSignal: options.abortSignal,
-                appendPositionAccessConditions: options.conditions,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            return await this.appendBlobContext.seal(Object.assign({ abortSignal: options.abortSignal, appendPositionAccessConditions: options.conditions, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Commits a new block of data to the end of the existing append blob.
@@ -1143,25 +1262,25 @@ export class AppendBlobClient extends BlobClient {
      * ```
      */
     async appendBlock(body, contentLength, options = {}) {
+        var _a;
+        const { span, updatedOptions } = createSpan("AppendBlobClient-appendBlock", options);
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("AppendBlobClient-appendBlock", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.appendBlobContext.appendBlock(contentLength, body, {
-                abortSignal: options.abortSignal,
-                appendPositionAccessConditions: options.conditions,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                requestOptions: {
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.appendBlobContext.appendBlock(contentLength, body, Object.assign({ abortSignal: options.abortSignal, appendPositionAccessConditions: options.conditions, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), requestOptions: {
                     onUploadProgress: options.onProgress,
-                },
-                transactionalContentMD5: options.transactionalContentMD5,
-                transactionalContentCrc64: options.transactionalContentCrc64,
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+                }, transactionalContentMD5: options.transactionalContentMD5, transactionalContentCrc64: options.transactionalContentCrc64, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * The Append Block operation commits a new block of data to the end of an existing append blob
@@ -1178,31 +1297,29 @@ export class AppendBlobClient extends BlobClient {
      * @param options -
      */
     async appendBlockFromURL(sourceURL, sourceOffset, count, options = {}) {
+        var _a;
+        const { span, updatedOptions } = createSpan("AppendBlobClient-appendBlockFromURL", options);
         options.conditions = options.conditions || {};
         options.sourceConditions = options.sourceConditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("AppendBlobClient-appendBlockFromURL", options, async (updatedOptions) => {
-            var _a, _b, _c, _d, _e;
-            return assertResponse(await this.appendBlobContext.appendBlockFromUrl(sourceURL, 0, {
-                abortSignal: options.abortSignal,
-                sourceRange: rangeToString({ offset: sourceOffset, count }),
-                sourceContentMD5: options.sourceContentMD5,
-                sourceContentCrc64: options.sourceContentCrc64,
-                leaseAccessConditions: options.conditions,
-                appendPositionAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                sourceModifiedAccessConditions: {
-                    sourceIfMatch: (_b = options.sourceConditions) === null || _b === void 0 ? void 0 : _b.ifMatch,
-                    sourceIfModifiedSince: (_c = options.sourceConditions) === null || _c === void 0 ? void 0 : _c.ifModifiedSince,
-                    sourceIfNoneMatch: (_d = options.sourceConditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch,
-                    sourceIfUnmodifiedSince: (_e = options.sourceConditions) === null || _e === void 0 ? void 0 : _e.ifUnmodifiedSince,
-                },
-                copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.appendBlobContext.appendBlockFromUrl(sourceURL, 0, Object.assign({ abortSignal: options.abortSignal, sourceRange: rangeToString({ offset: sourceOffset, count }), sourceContentMD5: options.sourceContentMD5, sourceContentCrc64: options.sourceContentCrc64, leaseAccessConditions: options.conditions, appendPositionAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), sourceModifiedAccessConditions: {
+                    sourceIfMatch: options.sourceConditions.ifMatch,
+                    sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
+                    sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
+                    sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince,
+                }, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
 }
 /**
@@ -1274,8 +1391,8 @@ export class BlockBlobClient extends BlobClient {
             throw new Error("Expecting non-empty strings for containerName and blobName parameters");
         }
         super(url, pipeline);
-        this.blockBlobContext = this.storageClientContext.blockBlob;
-        this._blobContext = this.storageClientContext.blob;
+        this.blockBlobContext = new BlockBlob(this.storageClientContext);
+        this._blobContext = new StorageBlob(this.storageClientContext);
     }
     /**
      * Creates a new BlockBlobClient object identical to the source but with the
@@ -1319,31 +1436,36 @@ export class BlockBlobClient extends BlobClient {
      * @param options -
      */
     async query(query, options = {}) {
+        var _a;
         ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        if (!isNode) {
-            throw new Error("This operation currently is only supported in Node.js.");
-        }
-        return tracingClient.withSpan("BlockBlobClient-query", options, async (updatedOptions) => {
-            var _a;
-            const response = assertResponse(await this._blobContext.query({
-                abortSignal: options.abortSignal,
-                queryRequest: {
+        const { span, updatedOptions } = createSpan("BlockBlobClient-query", options);
+        try {
+            if (!isNode) {
+                throw new Error("This operation currently is only supported in Node.js.");
+            }
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            const response = await this._blobContext.query(Object.assign({ abortSignal: options.abortSignal, queryRequest: {
                     queryType: "SQL",
                     expression: query,
                     inputSerialization: toQuerySerialization(options.inputTextConfiguration),
                     outputSerialization: toQuerySerialization(options.outputTextConfiguration),
-                },
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                cpkInfo: options.customerProvidedKey,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
+                }, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), cpkInfo: options.customerProvidedKey }, convertTracingToRequestOptionsBase(updatedOptions)));
             return new BlobQueryResponse(response, {
                 abortSignal: options.abortSignal,
                 onProgress: options.onProgress,
                 onError: options.onError,
             });
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Creates a new block blob, or updates the content of an existing block blob.
@@ -1373,29 +1495,25 @@ export class BlockBlobClient extends BlobClient {
      * ```
      */
     async upload(body, contentLength, options = {}) {
+        var _a, _b, _c;
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlockBlobClient-upload", options, async (updatedOptions) => {
-            var _a, _b, _c;
-            return assertResponse(await this.blockBlobContext.upload(contentLength, body, {
-                abortSignal: options.abortSignal,
-                blobHttpHeaders: options.blobHTTPHeaders,
-                leaseAccessConditions: options.conditions,
-                metadata: options.metadata,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                requestOptions: {
+        const { span, updatedOptions } = createSpan("BlockBlobClient-upload", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blockBlobContext.upload(contentLength, body, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), requestOptions: {
                     onUploadProgress: options.onProgress,
-                },
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn,
-                immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode,
-                legalHold: options.legalHold,
-                tier: toAccessTier(options.tier),
-                blobTagsString: toBlobTagsString(options.tags),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+                }, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode, legalHold: options.legalHold, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Creates a new Block Blob where the contents of the blob are read from a given URL.
@@ -1416,18 +1534,29 @@ export class BlockBlobClient extends BlobClient {
      * @param options - Optional parameters.
      */
     async syncUploadFromURL(sourceURL, options = {}) {
+        var _a, _b, _c, _d, _e;
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlockBlobClient-syncUploadFromURL", options, async (updatedOptions) => {
-            var _a, _b, _c, _d, _e, _f;
-            return assertResponse(await this.blockBlobContext.putBlobFromUrl(0, sourceURL, Object.assign(Object.assign({}, options), { blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), sourceModifiedAccessConditions: {
-                    sourceIfMatch: (_b = options.sourceConditions) === null || _b === void 0 ? void 0 : _b.ifMatch,
-                    sourceIfModifiedSince: (_c = options.sourceConditions) === null || _c === void 0 ? void 0 : _c.ifModifiedSince,
-                    sourceIfNoneMatch: (_d = options.sourceConditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch,
-                    sourceIfUnmodifiedSince: (_e = options.sourceConditions) === null || _e === void 0 ? void 0 : _e.ifUnmodifiedSince,
-                    sourceIfTags: (_f = options.sourceConditions) === null || _f === void 0 ? void 0 : _f.tagConditions,
-                }, cpkInfo: options.customerProvidedKey, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization), tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags), copySourceTags: options.copySourceTags, tracingOptions: updatedOptions.tracingOptions })));
-        });
+        const { span, updatedOptions } = createSpan("BlockBlobClient-syncUploadFromURL", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blockBlobContext.putBlobFromUrl(0, sourceURL, Object.assign(Object.assign(Object.assign({}, options), { blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: options.conditions.tagConditions }), sourceModifiedAccessConditions: {
+                    sourceIfMatch: (_a = options.sourceConditions) === null || _a === void 0 ? void 0 : _a.ifMatch,
+                    sourceIfModifiedSince: (_b = options.sourceConditions) === null || _b === void 0 ? void 0 : _b.ifModifiedSince,
+                    sourceIfNoneMatch: (_c = options.sourceConditions) === null || _c === void 0 ? void 0 : _c.ifNoneMatch,
+                    sourceIfUnmodifiedSince: (_d = options.sourceConditions) === null || _d === void 0 ? void 0 : _d.ifUnmodifiedSince,
+                    sourceIfTags: (_e = options.sourceConditions) === null || _e === void 0 ? void 0 : _e.tagConditions,
+                }, cpkInfo: options.customerProvidedKey, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization), tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags), copySourceTags: options.copySourceTags }), convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Uploads the specified block to the block blob's "staging area" to be later
@@ -1441,21 +1570,23 @@ export class BlockBlobClient extends BlobClient {
      * @returns Response data for the Block Blob Stage Block operation.
      */
     async stageBlock(blockId, body, contentLength, options = {}) {
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlockBlobClient-stageBlock", options, async (updatedOptions) => {
-            return assertResponse(await this.blockBlobContext.stageBlock(blockId, contentLength, body, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                requestOptions: {
+        const { span, updatedOptions } = createSpan("BlockBlobClient-stageBlock", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blockBlobContext.stageBlock(blockId, contentLength, body, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, requestOptions: {
                     onUploadProgress: options.onProgress,
-                },
-                transactionalContentMD5: options.transactionalContentMD5,
-                transactionalContentCrc64: options.transactionalContentCrc64,
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+                }, transactionalContentMD5: options.transactionalContentMD5, transactionalContentCrc64: options.transactionalContentCrc64, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * The Stage Block From URL operation creates a new block to be committed as part
@@ -1479,20 +1610,21 @@ export class BlockBlobClient extends BlobClient {
      * @returns Response data for the Block Blob Stage Block From URL operation.
      */
     async stageBlockFromURL(blockId, sourceURL, offset = 0, count, options = {}) {
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlockBlobClient-stageBlockFromURL", options, async (updatedOptions) => {
-            return assertResponse(await this.blockBlobContext.stageBlockFromURL(blockId, 0, sourceURL, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                sourceContentMD5: options.sourceContentMD5,
-                sourceContentCrc64: options.sourceContentCrc64,
-                sourceRange: offset === 0 && !count ? undefined : rangeToString({ offset, count }),
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("BlockBlobClient-stageBlockFromURL", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blockBlobContext.stageBlockFromURL(blockId, 0, sourceURL, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, sourceContentMD5: options.sourceContentMD5, sourceContentCrc64: options.sourceContentCrc64, sourceRange: offset === 0 && !count ? undefined : rangeToString({ offset, count }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Writes a blob by specifying the list of block IDs that make up the blob.
@@ -1507,26 +1639,23 @@ export class BlockBlobClient extends BlobClient {
      * @returns Response data for the Block Blob Commit Block List operation.
      */
     async commitBlockList(blocks, options = {}) {
+        var _a, _b, _c;
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("BlockBlobClient-commitBlockList", options, async (updatedOptions) => {
-            var _a, _b, _c;
-            return assertResponse(await this.blockBlobContext.commitBlockList({ latest: blocks }, {
-                abortSignal: options.abortSignal,
-                blobHttpHeaders: options.blobHTTPHeaders,
-                leaseAccessConditions: options.conditions,
-                metadata: options.metadata,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn,
-                immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode,
-                legalHold: options.legalHold,
-                tier: toAccessTier(options.tier),
-                blobTagsString: toBlobTagsString(options.tags),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("BlockBlobClient-commitBlockList", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.blockBlobContext.commitBlockList({ latest: blocks }, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode, legalHold: options.legalHold, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns the list of blocks that have been uploaded as part of a block blob
@@ -1539,14 +1668,10 @@ export class BlockBlobClient extends BlobClient {
      * @returns Response data for the Block Blob Get Block List operation.
      */
     async getBlockList(listType, options = {}) {
-        return tracingClient.withSpan("BlockBlobClient-getBlockList", options, async (updatedOptions) => {
-            var _a;
-            const res = assertResponse(await this.blockBlobContext.getBlockList(listType, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
+        var _a;
+        const { span, updatedOptions } = createSpan("BlockBlobClient-getBlockList", options);
+        try {
+            const res = await this.blockBlobContext.getBlockList(listType, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
             if (!res.committedBlocks) {
                 res.committedBlocks = [];
             }
@@ -1554,7 +1679,17 @@ export class BlockBlobClient extends BlobClient {
                 res.uncommittedBlocks = [];
             }
             return res;
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     // High level functions
     /**
@@ -1573,7 +1708,8 @@ export class BlockBlobClient extends BlobClient {
      * @param options -
      */
     async uploadData(data, options = {}) {
-        return tracingClient.withSpan("BlockBlobClient-uploadData", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("BlockBlobClient-uploadData", options);
+        try {
             if (isNode) {
                 let buffer;
                 if (data instanceof Buffer) {
@@ -1592,7 +1728,17 @@ export class BlockBlobClient extends BlobClient {
                 const browserBlob = new Blob([data]);
                 return this.uploadSeekableInternal((offset, size) => browserBlob.slice(offset, offset + size), browserBlob.size, updatedOptions);
             }
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * ONLY AVAILABLE IN BROWSERS.
@@ -1614,10 +1760,21 @@ export class BlockBlobClient extends BlobClient {
      * @returns Response data for the Blob Upload operation.
      */
     async uploadBrowserData(browserData, options = {}) {
-        return tracingClient.withSpan("BlockBlobClient-uploadBrowserData", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("BlockBlobClient-uploadBrowserData", options);
+        try {
             const browserBlob = new Blob([browserData]);
-            return this.uploadSeekableInternal((offset, size) => browserBlob.slice(offset, offset + size), browserBlob.size, updatedOptions);
-        });
+            return await this.uploadSeekableInternal((offset, size) => browserBlob.slice(offset, offset + size), browserBlob.size, updatedOptions);
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      *
@@ -1635,23 +1792,27 @@ export class BlockBlobClient extends BlobClient {
      * @returns Response data for the Blob Upload operation.
      */
     async uploadSeekableInternal(bodyFactory, size, options = {}) {
-        var _a, _b;
-        let blockSize = (_a = options.blockSize) !== null && _a !== void 0 ? _a : 0;
-        if (blockSize < 0 || blockSize > BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES) {
+        if (!options.blockSize) {
+            options.blockSize = 0;
+        }
+        if (options.blockSize < 0 || options.blockSize > BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES) {
             throw new RangeError(`blockSize option must be >= 0 and <= ${BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES}`);
         }
-        const maxSingleShotSize = (_b = options.maxSingleShotSize) !== null && _b !== void 0 ? _b : BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES;
-        if (maxSingleShotSize < 0 || maxSingleShotSize > BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES) {
+        if (options.maxSingleShotSize !== 0 && !options.maxSingleShotSize) {
+            options.maxSingleShotSize = BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES;
+        }
+        if (options.maxSingleShotSize < 0 ||
+            options.maxSingleShotSize > BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES) {
             throw new RangeError(`maxSingleShotSize option must be >= 0 and <= ${BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES}`);
         }
-        if (blockSize === 0) {
+        if (options.blockSize === 0) {
             if (size > BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES * BLOCK_BLOB_MAX_BLOCKS) {
                 throw new RangeError(`${size} is too larger to upload to a block blob.`);
             }
-            if (size > maxSingleShotSize) {
-                blockSize = Math.ceil(size / BLOCK_BLOB_MAX_BLOCKS);
-                if (blockSize < DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES) {
-                    blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
+            if (size > options.maxSingleShotSize) {
+                options.blockSize = Math.ceil(size / BLOCK_BLOB_MAX_BLOCKS);
+                if (options.blockSize < DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES) {
+                    options.blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
                 }
             }
         }
@@ -1661,11 +1822,12 @@ export class BlockBlobClient extends BlobClient {
         if (!options.conditions) {
             options.conditions = {};
         }
-        return tracingClient.withSpan("BlockBlobClient-uploadSeekableInternal", options, async (updatedOptions) => {
-            if (size <= maxSingleShotSize) {
-                return assertResponse(await this.upload(bodyFactory(0, size), size, updatedOptions));
+        const { span, updatedOptions } = createSpan("BlockBlobClient-uploadSeekableInternal", options);
+        try {
+            if (size <= options.maxSingleShotSize) {
+                return await this.upload(bodyFactory(0, size), size, updatedOptions);
             }
-            const numBlocks = Math.floor((size - 1) / blockSize) + 1;
+            const numBlocks = Math.floor((size - 1) / options.blockSize) + 1;
             if (numBlocks > BLOCK_BLOB_MAX_BLOCKS) {
                 throw new RangeError(`The buffer's size is too big or the BlockSize is too small;` +
                     `the number of blocks must be <= ${BLOCK_BLOB_MAX_BLOCKS}`);
@@ -1677,8 +1839,8 @@ export class BlockBlobClient extends BlobClient {
             for (let i = 0; i < numBlocks; i++) {
                 batch.addOperation(async () => {
                     const blockID = generateBlockID(blockIDPrefix, i);
-                    const start = blockSize * i;
-                    const end = i === numBlocks - 1 ? size : start + blockSize;
+                    const start = options.blockSize * i;
+                    const end = i === numBlocks - 1 ? size : start + options.blockSize;
                     const contentLength = end - start;
                     blockList.push(blockID);
                     await this.stageBlock(blockID, bodyFactory(start, contentLength), contentLength, {
@@ -1699,7 +1861,17 @@ export class BlockBlobClient extends BlobClient {
             }
             await batch.do();
             return this.commitBlockList(blockList, updatedOptions);
-        });
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * ONLY AVAILABLE IN NODE.JS RUNTIME.
@@ -1715,16 +1887,27 @@ export class BlockBlobClient extends BlobClient {
      * @returns Response data for the Blob Upload operation.
      */
     async uploadFile(filePath, options = {}) {
-        return tracingClient.withSpan("BlockBlobClient-uploadFile", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("BlockBlobClient-uploadFile", options);
+        try {
             const size = (await fsStat(filePath)).size;
-            return this.uploadSeekableInternal((offset, count) => {
+            return await this.uploadSeekableInternal((offset, count) => {
                 return () => fsCreateReadStream(filePath, {
                     autoClose: true,
                     end: count ? offset + count - 1 : Infinity,
                     start: offset,
                 });
-            }, size, Object.assign(Object.assign({}, options), { tracingOptions: updatedOptions.tracingOptions }));
-        });
+            }, size, Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * ONLY AVAILABLE IN NODE.JS RUNTIME.
@@ -1749,7 +1932,8 @@ export class BlockBlobClient extends BlobClient {
         if (!options.conditions) {
             options.conditions = {};
         }
-        return tracingClient.withSpan("BlockBlobClient-uploadStream", options, async (updatedOptions) => {
+        const { span, updatedOptions } = createSpan("BlockBlobClient-uploadStream", options);
+        try {
             let blockNum = 0;
             const blockIDPrefix = generateUuid();
             let transferProgress = 0;
@@ -1775,8 +1959,18 @@ export class BlockBlobClient extends BlobClient {
             // Outgoing queue shouldn't be empty.
             Math.ceil((maxConcurrency / 4) * 3));
             await scheduler.do();
-            return assertResponse(await this.commitBlockList(blockList, Object.assign(Object.assign({}, options), { tracingOptions: updatedOptions.tracingOptions })));
-        });
+            return await this.commitBlockList(blockList, Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
 }
 /**
@@ -1848,7 +2042,7 @@ export class PageBlobClient extends BlobClient {
             throw new Error("Expecting non-empty strings for containerName and blobName parameters");
         }
         super(url, pipeline);
-        this.pageBlobContext = this.storageClientContext.pageBlob;
+        this.pageBlobContext = new PageBlob(this.storageClientContext);
     }
     /**
      * Creates a new PageBlobClient object identical to the source but with the
@@ -1871,27 +2065,23 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Create operation.
      */
     async create(size, options = {}) {
+        var _a, _b, _c;
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("PageBlobClient-create", options, async (updatedOptions) => {
-            var _a, _b, _c;
-            return assertResponse(await this.pageBlobContext.create(0, size, {
-                abortSignal: options.abortSignal,
-                blobHttpHeaders: options.blobHTTPHeaders,
-                blobSequenceNumber: options.blobSequenceNumber,
-                leaseAccessConditions: options.conditions,
-                metadata: options.metadata,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn,
-                immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode,
-                legalHold: options.legalHold,
-                tier: toAccessTier(options.tier),
-                blobTagsString: toBlobTagsString(options.tags),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-create", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.pageBlobContext.create(0, size, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, blobSequenceNumber: options.blobSequenceNumber, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === void 0 ? void 0 : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === void 0 ? void 0 : _c.policyMode, legalHold: options.legalHold, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Creates a page blob of the specified length. Call uploadPages to upload data
@@ -1903,20 +2093,30 @@ export class PageBlobClient extends BlobClient {
      * @param options -
      */
     async createIfNotExists(size, options = {}) {
-        return tracingClient.withSpan("PageBlobClient-createIfNotExists", options, async (updatedOptions) => {
-            var _a, _b;
-            try {
-                const conditions = { ifNoneMatch: ETagAny };
-                const res = assertResponse(await this.create(size, Object.assign(Object.assign({}, options), { conditions, tracingOptions: updatedOptions.tracingOptions })));
-                return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
-            }
-            catch (e) {
-                if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "BlobAlreadyExists") {
-                    return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
-                }
-                throw e;
+        var _a, _b;
+        const { span, updatedOptions } = createSpan("PageBlobClient-createIfNotExists", options);
+        try {
+            const conditions = { ifNoneMatch: ETagAny };
+            const res = await this.create(size, Object.assign(Object.assign({}, options), { conditions, tracingOptions: updatedOptions.tracingOptions }));
+            return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
+        }
+        catch (e) {
+            if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === "BlobAlreadyExists") {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: "Expected exception when creating a blob only if it does not already exist.",
+                });
+                return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });
             }
-        });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Writes 1 or more pages to the page blob. The start and end offsets must be a multiple of 512.
@@ -1929,26 +2129,25 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Upload Pages operation.
      */
     async uploadPages(body, offset, count, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("PageBlobClient-uploadPages", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.pageBlobContext.uploadPages(count, body, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                requestOptions: {
+        const { span, updatedOptions } = createSpan("PageBlobClient-uploadPages", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.pageBlobContext.uploadPages(count, body, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), requestOptions: {
                     onUploadProgress: options.onProgress,
-                },
-                range: rangeToString({ offset, count }),
-                sequenceNumberAccessConditions: options.conditions,
-                transactionalContentMD5: options.transactionalContentMD5,
-                transactionalContentCrc64: options.transactionalContentCrc64,
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+                }, range: rangeToString({ offset, count }), sequenceNumberAccessConditions: options.conditions, transactionalContentMD5: options.transactionalContentMD5, transactionalContentCrc64: options.transactionalContentCrc64, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * The Upload Pages operation writes a range of pages to a page blob where the
@@ -1962,30 +2161,29 @@ export class PageBlobClient extends BlobClient {
      * @param options -
      */
     async uploadPagesFromURL(sourceURL, sourceOffset, destOffset, count, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
         options.sourceConditions = options.sourceConditions || {};
-        ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
-        return tracingClient.withSpan("PageBlobClient-uploadPagesFromURL", options, async (updatedOptions) => {
-            var _a, _b, _c, _d, _e;
-            return assertResponse(await this.pageBlobContext.uploadPagesFromURL(sourceURL, rangeToString({ offset: sourceOffset, count }), 0, rangeToString({ offset: destOffset, count }), {
-                abortSignal: options.abortSignal,
-                sourceContentMD5: options.sourceContentMD5,
-                sourceContentCrc64: options.sourceContentCrc64,
-                leaseAccessConditions: options.conditions,
-                sequenceNumberAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                sourceModifiedAccessConditions: {
-                    sourceIfMatch: (_b = options.sourceConditions) === null || _b === void 0 ? void 0 : _b.ifMatch,
-                    sourceIfModifiedSince: (_c = options.sourceConditions) === null || _c === void 0 ? void 0 : _c.ifModifiedSince,
-                    sourceIfNoneMatch: (_d = options.sourceConditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch,
-                    sourceIfUnmodifiedSince: (_e = options.sourceConditions) === null || _e === void 0 ? void 0 : _e.ifUnmodifiedSince,
-                },
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-uploadPagesFromURL", options);
+        try {
+            ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
+            return await this.pageBlobContext.uploadPagesFromURL(sourceURL, rangeToString({ offset: sourceOffset, count }), 0, rangeToString({ offset: destOffset, count }), Object.assign({ abortSignal: options.abortSignal, sourceContentMD5: options.sourceContentMD5, sourceContentCrc64: options.sourceContentCrc64, leaseAccessConditions: options.conditions, sequenceNumberAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), sourceModifiedAccessConditions: {
+                    sourceIfMatch: options.sourceConditions.ifMatch,
+                    sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
+                    sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
+                    sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince,
+                }, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Frees the specified pages from the page blob.
@@ -1997,20 +2195,22 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Clear Pages operation.
      */
     async clearPages(offset = 0, count, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("PageBlobClient-clearPages", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.pageBlobContext.clearPages(0, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                range: rangeToString({ offset, count }),
-                sequenceNumberAccessConditions: options.conditions,
-                cpkInfo: options.customerProvidedKey,
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-clearPages", options);
+        try {
+            return await this.pageBlobContext.clearPages(0, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), range: rangeToString({ offset, count }), sequenceNumberAccessConditions: options.conditions, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns the list of valid page ranges for a page blob or snapshot of a page blob.
@@ -2022,18 +2222,24 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Get Ranges operation.
      */
     async getPageRanges(offset = 0, count, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("PageBlobClient-getPageRanges", options, async (updatedOptions) => {
-            var _a;
-            const response = assertResponse(await this.pageBlobContext.getPageRanges({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                range: rangeToString({ offset, count }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-            return rangeResponseFromModel(response);
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-getPageRanges", options);
+        try {
+            return await this.pageBlobContext
+                .getPageRanges(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), range: rangeToString({ offset, count }) }, convertTracingToRequestOptionsBase(updatedOptions)))
+                .then(rangeResponseFromModel);
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * getPageRangesSegment returns a single segment of page ranges starting from the
@@ -2048,18 +2254,21 @@ export class PageBlobClient extends BlobClient {
      * @param options - Options to PageBlob Get Page Ranges Segment operation.
      */
     async listPageRangesSegment(offset = 0, count, marker, options = {}) {
-        return tracingClient.withSpan("PageBlobClient-getPageRangesSegment", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.pageBlobContext.getPageRanges({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                range: rangeToString({ offset, count }),
-                marker: marker,
-                maxPageSize: options.maxPageSize,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        var _a;
+        const { span, updatedOptions } = createSpan("PageBlobClient-getPageRangesSegment", options);
+        try {
+            return await this.pageBlobContext.getPageRanges(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), range: rangeToString({ offset, count }), marker: marker, maxPageSize: options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns an AsyncIterableIterator for {@link PageBlobGetPageRangesResponseModel}
@@ -2220,19 +2429,24 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Get Page Range Diff operation.
      */
     async getPageRangesDiff(offset, count, prevSnapshot, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("PageBlobClient-getPageRangesDiff", options, async (updatedOptions) => {
-            var _a;
-            const result = assertResponse(await this.pageBlobContext.getPageRangesDiff({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                prevsnapshot: prevSnapshot,
-                range: rangeToString({ offset, count }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-            return rangeResponseFromModel(result);
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-getPageRangesDiff", options);
+        try {
+            return await this.pageBlobContext
+                .getPageRangesDiff(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), prevsnapshot: prevSnapshot, range: rangeToString({ offset, count }) }, convertTracingToRequestOptionsBase(updatedOptions)))
+                .then(rangeResponseFromModel);
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * getPageRangesDiffSegment returns a single segment of page ranges starting from the
@@ -2248,23 +2462,25 @@ export class PageBlobClient extends BlobClient {
      * @param marker - A string value that identifies the portion of the get to be returned with the next get operation.
      * @param options - Options to the Page Blob Get Page Ranges Diff operation.
      */
-    async listPageRangesDiffSegment(offset, count, prevSnapshotOrUrl, marker, options = {}) {
-        return tracingClient.withSpan("PageBlobClient-getPageRangesDiffSegment", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.pageBlobContext.getPageRangesDiff({
-                abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal,
-                leaseAccessConditions: options === null || options === void 0 ? void 0 : options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.conditions), { ifTags: (_a = options === null || options === void 0 ? void 0 : options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                prevsnapshot: prevSnapshotOrUrl,
-                range: rangeToString({
+    async listPageRangesDiffSegment(offset, count, prevSnapshotOrUrl, marker, options) {
+        var _a;
+        const { span, updatedOptions } = createSpan("PageBlobClient-getPageRangesDiffSegment", options);
+        try {
+            return await this.pageBlobContext.getPageRangesDiff(Object.assign({ abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal, leaseAccessConditions: options === null || options === void 0 ? void 0 : options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.conditions), { ifTags: (_a = options === null || options === void 0 ? void 0 : options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), prevsnapshot: prevSnapshotOrUrl, range: rangeToString({
                     offset: offset,
                     count: count,
-                }),
-                marker: marker,
-                maxPageSize: options === null || options === void 0 ? void 0 : options.maxPageSize,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+                }), marker: marker, maxPageSize: options === null || options === void 0 ? void 0 : options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Returns an AsyncIterableIterator for {@link PageBlobGetPageRangesDiffResponseModel}
@@ -2429,19 +2645,24 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Get Page Range Diff operation.
      */
     async getPageRangesDiffForManagedDisks(offset, count, prevSnapshotUrl, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("PageBlobClient-GetPageRangesDiffForManagedDisks", options, async (updatedOptions) => {
-            var _a;
-            const response = assertResponse(await this.pageBlobContext.getPageRangesDiff({
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                prevSnapshotUrl,
-                range: rangeToString({ offset, count }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-            return rangeResponseFromModel(response);
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-GetPageRangesDiffForManagedDisks", options);
+        try {
+            return await this.pageBlobContext
+                .getPageRangesDiff(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), prevSnapshotUrl, range: rangeToString({ offset, count }) }, convertTracingToRequestOptionsBase(updatedOptions)))
+                .then(rangeResponseFromModel);
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Resizes the page blob to the specified size (which must be a multiple of 512).
@@ -2452,17 +2673,22 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Resize operation.
      */
     async resize(size, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("PageBlobClient-resize", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.pageBlobContext.resize(size, {
-                abortSignal: options.abortSignal,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                encryptionScope: options.encryptionScope,
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-resize", options);
+        try {
+            return await this.pageBlobContext.resize(size, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }), encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Sets a page blob's sequence number.
@@ -2474,17 +2700,22 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Update Sequence Number operation.
      */
     async updateSequenceNumber(sequenceNumberAction, sequenceNumber, options = {}) {
+        var _a;
         options.conditions = options.conditions || {};
-        return tracingClient.withSpan("PageBlobClient-updateSequenceNumber", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.pageBlobContext.updateSequenceNumber(sequenceNumberAction, {
-                abortSignal: options.abortSignal,
-                blobSequenceNumber: sequenceNumber,
-                leaseAccessConditions: options.conditions,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        const { span, updatedOptions } = createSpan("PageBlobClient-updateSequenceNumber", options);
+        try {
+            return await this.pageBlobContext.updateSequenceNumber(sequenceNumberAction, Object.assign({ abortSignal: options.abortSignal, blobSequenceNumber: sequenceNumber, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Begins an operation to start an incremental copy from one page blob's snapshot to this page blob.
@@ -2500,14 +2731,21 @@ export class PageBlobClient extends BlobClient {
      * @returns Response data for the Page Blob Copy Incremental operation.
      */
     async startCopyIncremental(copySource, options = {}) {
-        return tracingClient.withSpan("PageBlobClient-startCopyIncremental", options, async (updatedOptions) => {
-            var _a;
-            return assertResponse(await this.pageBlobContext.copyIncremental(copySource, {
-                abortSignal: options.abortSignal,
-                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),
-                tracingOptions: updatedOptions.tracingOptions,
-            }));
-        });
+        var _a;
+        const { span, updatedOptions } = createSpan("PageBlobClient-startCopyIncremental", options);
+        try {
+            return await this.pageBlobContext.copyIncremental(copySource, Object.assign({ abortSignal: options.abortSignal, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
+        }
+        catch (e) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
     }
 }
 //# sourceMappingURL=Clients.js.map