@azure/data-tables 13.0.2-alpha.20220214.1 → 13.1.0-alpha.20220216.2

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Release History
 
-## 13.0.2 (Unreleased)
+## 13.1.0 (Unreleased)
 
 ### Features Added
 
@@ -10,6 +10,10 @@
 
 ### Other Changes
 
+- Updated our `@azure/core-tracing` dependency to the latest version (1.0.0-preview.14)
+  - Notable changes include Removal of `@opentelemetry/api` as a transitive dependency and ensuring that the active context is properly propagated.
+  - Customers who would like to continue using OpenTelemetry driven tracing should visit our [OpenTelemetry Instrumentation](https://www.npmjs.com/package/@azure/opentelemetry-instrumentation-azure-sdk) package for instructions.
+
 ## 13.0.1 (2022-01-12)
 
 ### Bugs Fixed

package/dist/index.js

@@ -7,10 +7,10 @@ require('@azure/core-paging');
 var coreAuth = require('@azure/core-auth');
 var coreXml = require('@azure/core-xml');
 var coreClient = require('@azure/core-client');
-var coreTracing = require('@azure/core-tracing');
 var url$1 = require('url');
 var logger$1 = require('@azure/logger');
 var crypto = require('crypto');
+var coreTracing = require('@azure/core-tracing');
 var coreRestPipeline = require('@azure/core-rest-pipeline');
 var uuid = require('uuid');
 
@@ -3090,7 +3090,7 @@ class GeneratedClientContext extends coreClient__namespace.ServiceClient {
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-data-tables/13.0.2`;
+        const packageDetails = `azsdk-js-data-tables/13.1.0`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -3126,16 +3126,6 @@ class GeneratedClient extends GeneratedClientContext {
     }
 }
 
-// Copyright (c) Microsoft Corporation.
-/**
- * Creates a span using the global tracer.
- * @internal
- */
-const createSpan = coreTracing.createSpanFunction({
-    packagePrefix: "Azure.Data.Tables",
-    namespace: "Microsoft.Data.Tables",
-});
-
 // Copyright (c) Microsoft Corporation.
 /**
  * Gets client parameters from an Account Connection String
@@ -3308,8 +3298,9 @@ function getAccountNameFromUrl(url) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 function handleTableAlreadyExists(error, options = {}) {
-    var _a, _b, _c;
+    var _a, _b;
     const responseError = getErrorResponse(error);
     if (responseError &&
         responseError.status === 409 &&
@@ -3320,7 +3311,6 @@ function handleTableAlreadyExists(error, options = {}) {
         }
     }
     else {
-        options === null || options === void 0 ? void 0 : options.span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: (_c = error) === null || _c === void 0 ? void 0 : _c.message });
         throw error;
     }
 }
@@ -3438,6 +3428,17 @@ function signURLWithSAS(request, credential) {
     request.url = url.toString();
 }
 
+// Copyright (c) Microsoft Corporation.
+/**
+ * A tracing client that can be used to manage spans.
+ * @internal
+ */
+const tracingClient = coreTracing.createTracingClient({
+    namespace: "Microsoft.Data.Tables",
+    packageName: "@azure/data-tables",
+    packageVersion: "13.1.0",
+});
+
 // Copyright (c) Microsoft Corporation.
 /**
  * A TableServiceClient represents a Client to the Azure Tables service allowing you
@@ -3477,36 +3478,16 @@ class TableServiceClient {
      * secondary location endpoint when read-access geo-redundant replication is enabled for the account.
      * @param options - The options parameters.
      */
-    async getStatistics(options = {}) {
-        const { span, updatedOptions } = createSpan("TableServiceClient-getStatistics", options);
-        try {
-            return await this.service.getStatistics(updatedOptions);
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+    getStatistics(options = {}) {
+        return tracingClient.withSpan("TableServiceClient.getStatistics", options, (updatedOptions) => this.service.getStatistics(updatedOptions));
     }
     /**
      * Gets the properties of an account's Table service, including properties for Analytics and CORS
      * (Cross-Origin Resource Sharing) rules.
      * @param options - The options parameters.
      */
-    async getProperties(options = {}) {
-        const { span, updatedOptions } = createSpan("TableServiceClient-getProperties", options);
-        try {
-            return await this.service.getProperties(updatedOptions);
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+    getProperties(options = {}) {
+        return tracingClient.withSpan("TableServiceClient.getProperties", options, (updatedOptions) => this.service.getProperties(updatedOptions));
     }
     /**
      * Sets properties for an account's Table service endpoint, including properties for Analytics and CORS
@@ -3514,58 +3495,43 @@ class TableServiceClient {
      * @param properties - The Table Service properties.
      * @param options - The options parameters.
      */
-    async setProperties(properties, options = {}) {
-        const { span, updatedOptions } = createSpan("TableServiceClient-setProperties", options);
-        try {
-            return await this.service.setProperties(properties, updatedOptions);
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+    setProperties(properties, options = {}) {
+        return tracingClient.withSpan("TableServiceClient.setProperties", options, (updatedOptions) => this.service.setProperties(properties, updatedOptions));
     }
     /**
      * Creates a new table under the given account.
      * @param name - The name of the table.
      * @param options - The options parameters.
      */
-    async createTable(name, options = {}) {
-        const { span, updatedOptions } = createSpan("TableServiceClient-createTable", options);
-        try {
-            await this.table.create({ name }, Object.assign({}, updatedOptions));
-        }
-        catch (e) {
-            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { span, logger, tableName: name }));
-        }
-        finally {
-            span.end();
-        }
+    createTable(name, options = {}) {
+        return tracingClient.withSpan("TableServiceClient.createTable", options, async (updatedOptions) => {
+            try {
+                await this.table.create({ name }, updatedOptions);
+            }
+            catch (e) {
+                handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger, tableName: name }));
+            }
+        });
     }
     /**
      * Operation permanently deletes the specified table.
      * @param name - The name of the table.
      * @param options - The options parameters.
      */
-    async deleteTable(name, options = {}) {
-        const { span, updatedOptions } = createSpan("TableServiceClient-deleteTable", options);
-        try {
-            await this.table.delete(name, updatedOptions);
-        }
-        catch (e) {
-            if (e.statusCode === 404) {
-                logger.info("TableServiceClient-deleteTable: Table doesn't exist");
+    deleteTable(name, options = {}) {
+        return tracingClient.withSpan("TableServiceClient.deleteTable", options, async (updatedOptions) => {
+            try {
+                await this.table.delete(name, updatedOptions);
             }
-            else {
-                span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-                throw e;
+            catch (e) {
+                if (e.statusCode === 404) {
+                    logger.info("TableServiceClient-deleteTable: Table doesn't exist");
+                }
+                else {
+                    throw e;
+                }
             }
-        }
-        finally {
-            span.end();
-        }
+        });
     }
     /**
      * Queries tables under the given account.
@@ -3617,22 +3583,15 @@ class TableServiceClient {
     }
     listTablesPage(options = {}) {
         return tslib.__asyncGenerator(this, arguments, function* listTablesPage_1() {
-            const { span, updatedOptions } = createSpan("TableServiceClient-listTablesPage", options);
-            try {
-                let result = yield tslib.__await(this._listTables(updatedOptions));
+            let result = yield tslib.__await(tracingClient.withSpan("TableServiceClient.listTablesPage", options, (updatedOptions) => this._listTables(updatedOptions)));
+            yield yield tslib.__await(result);
+            while (result.continuationToken) {
+                const optionsWithContinuation = Object.assign(Object.assign({}, options), { continuationToken: result.continuationToken });
+                result = yield tslib.__await(tracingClient.withSpan("TableServiceClient.listTablesPage", optionsWithContinuation, async (updatedOptions, span) => {
+                    span.setAttribute("continuationToken", updatedOptions.continuationToken);
+                    return this._listTables(updatedOptions);
+                }));
                 yield yield tslib.__await(result);
-                while (result.continuationToken) {
-                    const optionsWithContinuation = Object.assign(Object.assign({}, updatedOptions), { continuationToken: result.continuationToken });
-                    result = yield tslib.__await(this._listTables(optionsWithContinuation));
-                    yield yield tslib.__await(result);
-                }
-            }
-            catch (e) {
-                span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-                throw e;
-            }
-            finally {
-                span.end();
             }
         });
     }
@@ -3970,29 +3929,18 @@ class InternalTableTransaction {
         await Promise.all(this.resetableState.pendingOperations);
         const body = getTransactionHttpRequestBody(this.resetableState.bodyParts, this.resetableState.transactionId, this.resetableState.changesetId);
         const headers = getTransactionHeaders(this.resetableState.transactionId);
-        const { span, updatedOptions } = createSpan("TableTransaction-submitTransaction", {});
-        const request = coreRestPipeline.createPipelineRequest({
-            url: this.url,
-            method: "POST",
-            body,
-            headers: coreRestPipeline.createHttpHeaders(headers),
-            tracingOptions: updatedOptions.tracingOptions,
-            allowInsecureConnection: this.allowInsecureConnection,
-        });
-        try {
+        return tracingClient.withSpan("TableTransaction.submitTransaction", {}, async (updatedOptions) => {
+            const request = coreRestPipeline.createPipelineRequest({
+                url: this.url,
+                method: "POST",
+                body,
+                headers: coreRestPipeline.createHttpHeaders(headers),
+                tracingOptions: updatedOptions.tracingOptions,
+                allowInsecureConnection: this.allowInsecureConnection,
+            });
             const rawTransactionResponse = await this.client.sendRequest(request);
             return parseTransactionResponse(rawTransactionResponse);
-        }
-        catch (error) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: error.message,
-            });
-            throw error;
-        }
-        finally {
-            span.end();
-        }
+        });
     }
     checkPartitionKey(partitionKey) {
         if (this.resetableState.partitionKey !== partitionKey) {
@@ -4453,23 +4401,17 @@ class TableClient {
      * ```
      */
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
-    async deleteTable(options = {}) {
-        const { span, updatedOptions } = createSpan("TableClient-deleteTable", options);
-        try {
-            await this.table.delete(this.tableName, updatedOptions);
-        }
-        catch (e) {
-            if (e.statusCode === 404) {
-                logger.info("TableClient-deleteTable: Table doesn't exist");
+    deleteTable(options = {}) {
+        return tracingClient.withSpan("TableClient.deleteTable", options, async (updatedOptions) => {
+            try {
+                await this.table.delete(this.tableName, updatedOptions);
             }
-            else {
-                span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-                throw e;
+            catch (e) {
+                if (e.statusCode === 404) {
+                    logger.info("TableClient.deleteTable: Table doesn't exist");
+                }
             }
-        }
-        finally {
-            span.end();
-        }
+        });
     }
     /**
      *  Creates a table with the tableName passed to the client constructor
@@ -4497,17 +4439,15 @@ class TableClient {
      * ```
      */
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
-    async createTable(options = {}) {
-        const { span, updatedOptions } = createSpan("TableClient-createTable", options);
-        try {
-            await this.table.create({ name: this.tableName }, updatedOptions);
-        }
-        catch (e) {
-            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { span, logger, tableName: this.tableName }));
-        }
-        finally {
-            span.end();
-        }
+    createTable(options = {}) {
+        return tracingClient.withSpan("TableClient.createTable", options, async (updatedOptions) => {
+            try {
+                await this.table.create({ name: this.tableName }, updatedOptions);
+            }
+            catch (e) {
+                handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger, tableName: this.tableName }));
+            }
+        });
     }
     /**
      * Returns a single entity in the table.
@@ -4536,30 +4476,22 @@ class TableClient {
      * console.log(entity);
      * ```
      */
-    async getEntity(partitionKey, rowKey, 
+    getEntity(partitionKey, rowKey, 
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options = {}) {
-        const { span, updatedOptions } = createSpan("TableClient-getEntity", options);
-        let parsedBody;
-        function onResponse(rawResponse, flatResponse) {
-            parsedBody = rawResponse.parsedBody;
-            if (updatedOptions.onResponse) {
-                updatedOptions.onResponse(rawResponse, flatResponse);
+        return tracingClient.withSpan("TableClient.getEntity", options, async (updatedOptions) => {
+            let parsedBody;
+            function onResponse(rawResponse, flatResponse) {
+                parsedBody = rawResponse.parsedBody;
+                if (updatedOptions.onResponse) {
+                    updatedOptions.onResponse(rawResponse, flatResponse);
+                }
             }
-        }
-        try {
-            const _a = updatedOptions || {}, { disableTypeConversion, queryOptions } = _a, getEntityOptions = tslib.__rest(_a, ["disableTypeConversion", "queryOptions"]);
+            const { disableTypeConversion, queryOptions } = updatedOptions, getEntityOptions = tslib.__rest(updatedOptions, ["disableTypeConversion", "queryOptions"]);
             await this.table.queryEntitiesWithPartitionAndRowKey(this.tableName, escapeQuotes(partitionKey), escapeQuotes(rowKey), Object.assign(Object.assign({}, getEntityOptions), { queryOptions: serializeQueryOptions(queryOptions || {}), onResponse }));
             const tableEntity = deserialize(parsedBody, disableTypeConversion !== null && disableTypeConversion !== void 0 ? disableTypeConversion : false);
             return tableEntity;
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+        });
     }
     /**
      * Queries entities in a table.
@@ -4637,25 +4569,15 @@ class TableClient {
     }
     listEntitiesPage(tableName, options = {}) {
         return tslib.__asyncGenerator(this, arguments, function* listEntitiesPage_1() {
-            const { span, updatedOptions } = createSpan("TableClient-listEntitiesPage", options);
-            try {
-                let result = yield tslib.__await(this._listEntities(tableName, updatedOptions));
+            let result = yield tslib.__await(tracingClient.withSpan("TableClient.listEntitiesPage", options, (updatedOptions) => this._listEntities(tableName, updatedOptions)));
+            yield yield tslib.__await(result);
+            while (result.continuationToken) {
+                const optionsWithContinuation = Object.assign(Object.assign({}, options), { continuationToken: result.continuationToken });
+                result = yield tslib.__await(tracingClient.withSpan("TableClient.listEntitiesPage", optionsWithContinuation, (updatedOptions, span) => {
+                    span.setAttribute("continuationToken", result.continuationToken);
+                    return this._listEntities(tableName, updatedOptions);
+                }));
                 yield yield tslib.__await(result);
-                while (result.continuationToken) {
-                    const optionsWithContinuation = Object.assign(Object.assign({}, updatedOptions), { continuationToken: result.continuationToken });
-                    result = yield tslib.__await(this._listEntities(tableName, optionsWithContinuation));
-                    yield yield tslib.__await(result);
-                }
-            }
-            catch (e) {
-                span.setStatus({
-                    code: coreTracing.SpanStatusCode.ERROR,
-                    message: e.message,
-                });
-                throw e;
-            }
-            finally {
-                span.end();
             }
         });
     }
@@ -4703,21 +4625,13 @@ class TableClient {
      * await client.createEntity({partitionKey: "p1", rowKey: "r1", foo: "Hello!"});
      * ```
      */
-    async createEntity(entity, 
+    createEntity(entity, 
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options = {}) {
-        const { span, updatedOptions } = createSpan("TableClient-createEntity", options);
-        try {
+        return tracingClient.withSpan("TableClient.createEntity", options, (updatedOptions) => {
             const createTableEntity = tslib.__rest(updatedOptions || {}, []);
-            return await this.table.insertEntity(this.tableName, Object.assign(Object.assign({}, createTableEntity), { tableEntityProperties: serialize(entity), responsePreference: "return-no-content" }));
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+            return this.table.insertEntity(this.tableName, Object.assign(Object.assign({}, createTableEntity), { tableEntityProperties: serialize(entity), responsePreference: "return-no-content" }));
+        });
     }
     /**
      * Deletes the specified entity in the table.
@@ -4744,22 +4658,14 @@ class TableClient {
      * await client.deleteEntity("<partitionKey>", "<rowKey>")
      * ```
      */
-    async deleteEntity(partitionKey, rowKey, 
+    deleteEntity(partitionKey, rowKey, 
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options = {}) {
-        const { span, updatedOptions } = createSpan("TableClient-deleteEntity", options);
-        try {
-            const _a = updatedOptions || {}, { etag = "*" } = _a, rest = tslib.__rest(_a, ["etag"]);
+        return tracingClient.withSpan("TableClient.deleteEntity", options, (updatedOptions) => {
+            const { etag = "*" } = updatedOptions, rest = tslib.__rest(updatedOptions, ["etag"]);
             const deleteOptions = Object.assign({}, rest);
-            return await this.table.deleteEntity(this.tableName, escapeQuotes(partitionKey), escapeQuotes(rowKey), etag, deleteOptions);
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+            return this.table.deleteEntity(this.tableName, escapeQuotes(partitionKey), escapeQuotes(rowKey), etag, deleteOptions);
+        });
     }
     /**
      * Update an entity in the table.
@@ -4800,29 +4706,25 @@ class TableClient {
      * await client.updateEntity(entity, "Replace")
      * ```
      */
-    async updateEntity(entity, mode = "Merge", 
+    updateEntity(entity, mode = "Merge", 
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options = {}) {
-        const { span, updatedOptions } = createSpan(`TableClient-updateEntity-${mode}`, options);
-        try {
+        return tracingClient.withSpan("TableClient.updateEntity", options, async (updatedOptions) => {
             const partitionKey = escapeQuotes(entity.partitionKey);
             const rowKey = escapeQuotes(entity.rowKey);
             const _a = updatedOptions || {}, { etag = "*" } = _a, updateEntityOptions = tslib.__rest(_a, ["etag"]);
             if (mode === "Merge") {
-                return await this.table.mergeEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity), ifMatch: etag }, updateEntityOptions));
+                return this.table.mergeEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity), ifMatch: etag }, updateEntityOptions));
             }
             if (mode === "Replace") {
-                return await this.table.updateEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity), ifMatch: etag }, updateEntityOptions));
+                return this.table.updateEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity), ifMatch: etag }, updateEntityOptions));
             }
             throw new Error(`Unexpected value for update mode: ${mode}`);
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+        }, {
+            spanAttributes: {
+                updateEntityMode: mode,
+            },
+        });
     }
     /**
      * Upsert an entity in the table.
@@ -4859,66 +4761,46 @@ class TableClient {
      * await client.upsertEntity(entity, "Replace")
      * ```
      */
-    async upsertEntity(entity, mode = "Merge", 
+    upsertEntity(entity, mode = "Merge", 
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options = {}) {
-        const { span, updatedOptions } = createSpan(`TableClient-upsertEntity-${mode}`, options);
-        try {
+        return tracingClient.withSpan("TableClient.upsertEntity", options, async (updatedOptions) => {
             const partitionKey = escapeQuotes(entity.partitionKey);
             const rowKey = escapeQuotes(entity.rowKey);
             if (mode === "Merge") {
-                return await this.table.mergeEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity) }, updatedOptions));
+                return this.table.mergeEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity) }, updatedOptions));
             }
             if (mode === "Replace") {
-                return await this.table.updateEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity) }, updatedOptions));
+                return this.table.updateEntity(this.tableName, partitionKey, rowKey, Object.assign({ tableEntityProperties: serialize(entity) }, updatedOptions));
             }
             throw new Error(`Unexpected value for update mode: ${mode}`);
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+        }, {
+            spanAttributes: {
+                upsertEntityMode: mode,
+            },
+        });
     }
     /**
      * Retrieves details about any stored access policies specified on the table that may be used with
      * Shared Access Signatures.
      * @param options - The options parameters.
      */
-    async getAccessPolicy(options = {}) {
-        const { span, updatedOptions } = createSpan("TableClient-getAccessPolicy", options);
-        try {
+    getAccessPolicy(options = {}) {
+        return tracingClient.withSpan("TableClient.getAccessPolicy", options, async (updatedOptions) => {
             const signedIdentifiers = await this.table.getAccessPolicy(this.tableName, updatedOptions);
             return deserializeSignedIdentifier(signedIdentifiers);
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+        });
     }
     /**
      * Sets stored access policies for the table that may be used with Shared Access Signatures.
      * @param tableAcl - The Access Control List for the table.
      * @param options - The options parameters.
      */
-    async setAccessPolicy(tableAcl, options = {}) {
-        const { span, updatedOptions } = createSpan("TableClient-setAccessPolicy", options);
-        try {
+    setAccessPolicy(tableAcl, options = {}) {
+        return tracingClient.withSpan("TableClient.setAccessPolicy", options, (updatedOptions) => {
             const serlializedAcl = serializeSignedIdentifiers(tableAcl);
-            return await this.table.setAccessPolicy(this.tableName, Object.assign(Object.assign({}, updatedOptions), { tableAcl: serlializedAcl }));
-        }
-        catch (e) {
-            span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
+            return this.table.setAccessPolicy(this.tableName, Object.assign(Object.assign({}, updatedOptions), { tableAcl: serlializedAcl }));
+        });
     }
     /**
      * Submits a Transaction which is composed of a set of actions. You can provide the actions as a list