resolving comments

sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/CosmosAsyncClient.java

@@ -479,17 +479,13 @@ private Mono<CosmosDatabaseResponse> createDatabaseIfNotExistsInternal(CosmosAsy
     private Mono<CosmosDatabaseResponse> createDatabaseInternal(Database database, CosmosDatabaseRequestOptions options,
                                                              Context context) {
         String spanName = "createDatabase." + database.getId();
-        Mono<CosmosDatabaseResponse> responseMono = createDatabaseInternal(database, options);
+        Mono<CosmosDatabaseResponse> responseMono = asyncDocumentClient.createDatabase(database, ModelBridgeInternal.toRequestOptions(options))
+            .map(databaseResourceResponse -> ModelBridgeInternal.createCosmosDatabaseResponse(databaseResourceResponse))
+            .single();
         return tracerProvider.traceEnabledCosmosResponsePublisher(responseMono,
             context,
             spanName,
             database.getId(),
             this.serviceEndpoint);
     }
-
-    private Mono<CosmosDatabaseResponse> createDatabaseInternal(Database database, CosmosDatabaseRequestOptions options) {
-        return asyncDocumentClient.createDatabase(database, ModelBridgeInternal.toRequestOptions(options))
-            .map(databaseResourceResponse -> ModelBridgeInternal.createCosmosDatabaseResponse(databaseResourceResponse))
-            .single();
-    }
 }

sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/CosmosAsyncContainer.java

@@ -700,86 +700,62 @@ private Mono<CosmosItemResponse<Object>> deleteItemInternal(
         String itemId,
         RequestOptions requestOptions,
         Context context) {
-        Mono<CosmosItemResponse<Object>> responseMono = deleteItemInternal(itemId, requestOptions);
+        Mono<CosmosItemResponse<Object>> responseMono = this.getDatabase()
+            .getDocClientWrapper()
+            .deleteDocument(getItemLink(itemId), requestOptions)
+            .map(response -> ModelBridgeInternal.createCosmosAsyncItemResponseWithObjectType(response))
+            .single();
         return database.getClient().getTracerProvider().traceEnabledCosmosItemResponsePublisher(responseMono,
             context,
             this.deleteItemSpanName,
             database.getId(),
             database.getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosItemResponse<Object>> deleteItemInternal(
-        String itemId,
-        RequestOptions requestOptions) {
-        return this.getDatabase()
-            .getDocClientWrapper()
-            .deleteDocument(getItemLink(itemId), requestOptions)
-            .map(response -> ModelBridgeInternal.createCosmosAsyncItemResponseWithObjectType(response))
-            .single();
-    }
-
     private <T> Mono<CosmosItemResponse<T>> replaceItemInternal(
         Class<T> itemType,
         String itemId,
         Document doc,
         CosmosItemRequestOptions options,
         Context context) {
-        Mono<CosmosItemResponse<T>> responseMono = replaceItemInternal(itemType, itemId, doc, options);
-        return database.getClient().getTracerProvider().traceEnabledCosmosItemResponsePublisher(responseMono,
-            context, this.replaceItemSpanName, database.getId(), database.getClient().getServiceEndpoint());
-    }
-
-    private <T> Mono<CosmosItemResponse<T>> replaceItemInternal(
-        Class<T> itemType,
-        String itemId,
-        Document doc,
-        CosmosItemRequestOptions options) {
-       return this.getDatabase()
+        Mono<CosmosItemResponse<T>> responseMono = this.getDatabase()
             .getDocClientWrapper()
             .replaceDocument(getItemLink(itemId), doc, ModelBridgeInternal.toRequestOptions(options))
             .map(response -> ModelBridgeInternal.createCosmosAsyncItemResponse(response, itemType))
             .single();
-    }
-
-    private <T> Mono<CosmosItemResponse<T>> upsertItemInternal(T item, CosmosItemRequestOptions options, Context context) {
-        Mono<CosmosItemResponse<T>> responseMono = upsertItemInternal(item, options);
         return database.getClient().getTracerProvider().traceEnabledCosmosItemResponsePublisher(responseMono,
-            context,
-            this.upsertItemSpanName,
-            database.getId(),
-            database.getClient().getServiceEndpoint());
+            context, this.replaceItemSpanName, database.getId(), database.getClient().getServiceEndpoint());
     }
 
-    private <T> Mono<CosmosItemResponse<T>> upsertItemInternal(T item, CosmosItemRequestOptions options) {
+    private <T> Mono<CosmosItemResponse<T>> upsertItemInternal(T item, CosmosItemRequestOptions options, Context context) {
         @SuppressWarnings("unchecked")
         Class<T> itemType = (Class<T>) item.getClass();
-        return this.getDatabase().getDocClientWrapper()
+        Mono<CosmosItemResponse<T>> responseMono = this.getDatabase().getDocClientWrapper()
             .upsertDocument(this.getLink(), item,
                 ModelBridgeInternal.toRequestOptions(options),
                 true)
             .map(response -> ModelBridgeInternal.createCosmosAsyncItemResponse(response, itemType))
             .single();
-    }
-
-    private <T> Mono<CosmosItemResponse<T>> readItemInternal(
-        String itemId,
-        RequestOptions requestOptions, Class<T> itemType,
-        Context context) {
-        Mono<CosmosItemResponse<T>> responseMono = readItemInternal(itemId, requestOptions, itemType);
         return database.getClient().getTracerProvider().traceEnabledCosmosItemResponsePublisher(responseMono,
             context,
-            this.readItemSpanName,
+            this.upsertItemSpanName,
             database.getId(),
             database.getClient().getServiceEndpoint());
     }
 
     private <T> Mono<CosmosItemResponse<T>> readItemInternal(
         String itemId,
-        RequestOptions requestOptions, Class<T> itemType) {
-        return this.getDatabase().getDocClientWrapper()
+        RequestOptions requestOptions, Class<T> itemType,
+        Context context) {
+        Mono<CosmosItemResponse<T>> responseMono = this.getDatabase().getDocClientWrapper()
             .readDocument(getItemLink(itemId), requestOptions)
             .map(response -> ModelBridgeInternal.createCosmosAsyncItemResponse(response, itemType))
             .single();
+        return database.getClient().getTracerProvider().traceEnabledCosmosItemResponsePublisher(responseMono,
+            context,
+            this.readItemSpanName,
+            database.getId(),
+            database.getClient().getServiceEndpoint());
     }
 
     Mono<CosmosContainerResponse> read(CosmosContainerRequestOptions options, Context context) {
@@ -794,39 +770,30 @@ Mono<CosmosContainerResponse> read(CosmosContainerRequestOptions options, Contex
     }
 
     private Mono<CosmosContainerResponse> deleteInternal(CosmosContainerRequestOptions options, Context context) {
-        Mono<CosmosContainerResponse> responseMono = deleteInternal(options);
+        Mono<CosmosContainerResponse> responseMono = database.getDocClientWrapper().deleteCollection(getLink(),
+            ModelBridgeInternal.toRequestOptions(options))
+            .map(response -> ModelBridgeInternal.createCosmosContainerResponse(response)).single();
         return database.getClient().getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono,
             context,
             this.deleteContainerSpanName,
             database.getId(),
             database.getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosContainerResponse> deleteInternal(CosmosContainerRequestOptions options) {
-        return database.getDocClientWrapper().deleteCollection(getLink(),
-            ModelBridgeInternal.toRequestOptions(options))
-            .map(response -> ModelBridgeInternal.createCosmosContainerResponse(response)).single();
-    }
-
     private Mono<CosmosContainerResponse> replaceInternal(CosmosContainerProperties containerProperties,
                                                                CosmosContainerRequestOptions options,
                                                                Context context) {
-        Mono<CosmosContainerResponse> responseMono = replaceInternal(containerProperties, options);
+        Mono<CosmosContainerResponse> responseMono = database.getDocClientWrapper()
+            .replaceCollection(ModelBridgeInternal.getV2Collection(containerProperties),
+                ModelBridgeInternal.toRequestOptions(options))
+            .map(response -> ModelBridgeInternal.createCosmosContainerResponse(response)).single();
         return database.getClient().getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono,
             context,
             this.replaceContainerSpanName,
             database.getId(),
             database.getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosContainerResponse> replaceInternal(CosmosContainerProperties containerProperties,
-                                                               CosmosContainerRequestOptions options) {
-        return database.getDocClientWrapper()
-            .replaceCollection(ModelBridgeInternal.getV2Collection(containerProperties),
-                ModelBridgeInternal.toRequestOptions(options))
-            .map(response -> ModelBridgeInternal.createCosmosContainerResponse(response)).single();
-    }
-
     private Mono<ThroughputResponse> readThroughputInternal(Context context) {
         Context nestedContext = context.addData(TracerProvider.COSMOS_CALL_DEPTH, TracerProvider.COSMOS_CALL_DEPTH_VAL);
         Mono<ThroughputResponse> responseMono = readThroughputInternal(this.read(new CosmosContainerRequestOptions(),

sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/CosmosAsyncDatabase.java

@@ -756,78 +756,56 @@ private Mono<CosmosContainerResponse> createContainerInternal(
         CosmosContainerRequestOptions options,
         Context context) {
         String spanName = "createContainer." + containerProperties.getId();
-        Mono<CosmosContainerResponse> responseMono = createContainerInternal(containerProperties, options);
+        Mono<CosmosContainerResponse> responseMono = getDocClientWrapper()
+            .createCollection(this.getLink(), ModelBridgeInternal.getV2Collection(containerProperties),
+                ModelBridgeInternal.toRequestOptions(options))
+            .map(response -> ModelBridgeInternal.createCosmosContainerResponse(response)).single();
         return this.client.getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
             spanName,
             getId(),
             getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosContainerResponse> createContainerInternal(
-        CosmosContainerProperties containerProperties,
-        CosmosContainerRequestOptions options) {
-        return getDocClientWrapper()
-            .createCollection(this.getLink(), ModelBridgeInternal.getV2Collection(containerProperties),
-                ModelBridgeInternal.toRequestOptions(options))
-            .map(response -> ModelBridgeInternal.createCosmosContainerResponse(response)).single();
-    }
-
     Mono<CosmosDatabaseResponse> readInternal(CosmosDatabaseRequestOptions options, Context context) {
         String spanName = "readDatabase." + this.getId();
-        Mono<CosmosDatabaseResponse> responseMono = readInternal(options);
+        Mono<CosmosDatabaseResponse> responseMono = getDocClientWrapper().readDatabase(getLink(),
+            ModelBridgeInternal.toRequestOptions(options))
+            .map(response -> ModelBridgeInternal.createCosmosDatabaseResponse(response)).single();
         return this.client.getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
             spanName,
             getId(),
             getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosDatabaseResponse> readInternal(CosmosDatabaseRequestOptions options) {
-        return getDocClientWrapper().readDatabase(getLink(),
-            ModelBridgeInternal.toRequestOptions(options))
-            .map(response -> ModelBridgeInternal.createCosmosDatabaseResponse(response)).single();
-    }
-
     private Mono<CosmosDatabaseResponse> deleteInternal(CosmosDatabaseRequestOptions options, Context context) {
         String spanName = "deleteDatabase." + this.getId();
-        Mono<CosmosDatabaseResponse> responseMono = deleteInternal(options);
+        Mono<CosmosDatabaseResponse> responseMono = getDocClientWrapper().deleteDatabase(getLink(),
+            ModelBridgeInternal.toRequestOptions(options))
+            .map(response -> ModelBridgeInternal.createCosmosDatabaseResponse(response)).single();
         return this.client.getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
             spanName,
             getId(),
             getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosDatabaseResponse> deleteInternal(CosmosDatabaseRequestOptions options) {
-        return getDocClientWrapper().deleteDatabase(getLink(),
-            ModelBridgeInternal.toRequestOptions(options))
-            .map(response -> ModelBridgeInternal.createCosmosDatabaseResponse(response)).single();
-    }
-
     private Mono<CosmosUserResponse> createUserInternal(CosmosUserProperties userProperties, Context context) {
         String spanName = "createUser." + this.getId();
-        Mono<CosmosUserResponse> responseMono = createUserInternal(userProperties);
+        Mono<CosmosUserResponse> responseMono = getDocClientWrapper().createUser(this.getLink(), ModelBridgeInternal.getV2User(userProperties), null)
+            .map(response -> ModelBridgeInternal.createCosmosUserResponse(response)).single();
         return this.client.getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
             spanName,
             getId(),
             getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosUserResponse> createUserInternal(CosmosUserProperties userProperties) {
-       return getDocClientWrapper().createUser(this.getLink(), ModelBridgeInternal.getV2User(userProperties), null)
-            .map(response -> ModelBridgeInternal.createCosmosUserResponse(response)).single();
-    }
-
     private Mono<CosmosUserResponse> upsertUserInternal(CosmosUserProperties userProperties, Context context) {
         String spanName = "upsertUser." + this.getId();
-        Mono<CosmosUserResponse> responseMono = upsertUserInternal(userProperties);
+        Mono<CosmosUserResponse> responseMono = getDocClientWrapper().upsertUser(this.getLink(), ModelBridgeInternal.getV2User(userProperties), null)
+            .map(response -> ModelBridgeInternal.createCosmosUserResponse(response)).single();
         return this.client.getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
             spanName, getId(), getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosUserResponse> upsertUserInternal(CosmosUserProperties userProperties) {
-        return getDocClientWrapper().upsertUser(this.getLink(), ModelBridgeInternal.getV2User(userProperties), null)
-            .map(response -> ModelBridgeInternal.createCosmosUserResponse(response)).single();
-    }
-
     private Mono<ThroughputResponse> replaceThroughputInternal(ThroughputProperties throughputProperties, Context context){
         String spanName = "replaceThroughput." + this.getId();
         Context nestedContext = context.addData(TracerProvider.COSMOS_CALL_DEPTH, TracerProvider.COSMOS_CALL_DEPTH_VAL);

sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/CosmosAsyncPermission.java

@@ -141,42 +141,31 @@ private Mono<CosmosPermissionResponse> replaceInternal(CosmosPermissionPropertie
                                                                 Context context) {
 
         String spanName = "replacePermission." + cosmosUser.getId();
-        Mono<CosmosPermissionResponse> responseMono = replaceInternal(permissionProperties, options);
-        return cosmosUser.getDatabase().getClient().getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
-            spanName,
-            cosmosUser.getDatabase().getId(),
-            cosmosUser.getDatabase().getClient().getServiceEndpoint());
-    }
-
-    private Mono<CosmosPermissionResponse> replaceInternal(CosmosPermissionProperties permissionProperties,
-                                                                CosmosPermissionRequestOptions options) {
         CosmosAsyncDatabase databaseContext = cosmosUser.getDatabase();
-        return cosmosUser.getDatabase()
+        Mono<CosmosPermissionResponse> responseMono = cosmosUser.getDatabase()
             .getDocClientWrapper()
             .replacePermission(ModelBridgeInternal.getPermission(permissionProperties, databaseContext.getId()),
                 ModelBridgeInternal.toRequestOptions(options))
             .map(response -> ModelBridgeInternal.createCosmosPermissionResponse(response))
             .single();
-    }
-
-    private Mono<CosmosPermissionResponse> deleteInternal(CosmosPermissionRequestOptions options,
-                                                               Context context) {
-
-        String spanName = "deletePermission." + cosmosUser.getId();
-        Mono<CosmosPermissionResponse> responseMono = deleteInternal(options);
         return cosmosUser.getDatabase().getClient().getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
             spanName,
             cosmosUser.getDatabase().getId(),
             cosmosUser.getDatabase().getClient().getServiceEndpoint());
     }
 
-    private Mono<CosmosPermissionResponse> deleteInternal(CosmosPermissionRequestOptions options) {
+    private Mono<CosmosPermissionResponse> deleteInternal(CosmosPermissionRequestOptions options,
+                                                               Context context) {
 
-        return cosmosUser.getDatabase()
+        String spanName = "deletePermission." + cosmosUser.getId();
+        Mono<CosmosPermissionResponse> responseMono = cosmosUser.getDatabase()
             .getDocClientWrapper()
             .deletePermission(getLink(), ModelBridgeInternal.toRequestOptions(options))
             .map(response -> ModelBridgeInternal.createCosmosPermissionResponse(response))
             .single();
+        return cosmosUser.getDatabase().getClient().getTracerProvider().traceEnabledCosmosResponsePublisher(responseMono, context,
+            spanName,
+            cosmosUser.getDatabase().getId(),
+            cosmosUser.getDatabase().getClient().getServiceEndpoint());
     }
-
 }