[ai-form-recognizer] Add tracing spans and tests (Azure#20646)

* [ai-form-recognizer] Add tracing spans and tests.

* Fixed copyright header.

Author: witemple-msft

sdk/formrecognizer/ai-form-recognizer/src/documentAnalysisClient.ts

@@ -336,19 +336,23 @@ export class DocumentAnalysisClient {
     input: string | FormRecognizerRequestBody,
     options: AnalyzeDocumentOptions<unknown> = {}
   ): Promise<AnalysisPoller<unknown>> {
-    const initialModelId = typeof model === "string" ? model : model.modelId;
-
-    const analysisPoller = this.createAnalysisPoller<unknown>(input, {
-      initialModelId,
+    return this._tracing.withSpan(
+      "DocumentAnalysisClient.beginAnalyzeDocument",
       options,
-      transformResult: (result) =>
-        toAnalyzeResultFromGenerated(
-          result,
-          typeof model === "string" ? toAnalyzedDocumentFromGenerated : getMapper(model)
-        ),
-    });
+      (finalOptions) => {
+        const initialModelId = typeof model === "string" ? model : model.modelId;
 
-    return analysisPoller;
+        return this.createAnalysisPoller<unknown>(input, {
+          initialModelId,
+          options: finalOptions,
+          transformResult: (result) =>
+            toAnalyzeResultFromGenerated(
+              result,
+              typeof model === "string" ? toAnalyzedDocumentFromGenerated : getMapper(model)
+            ),
+        });
+      }
+    );
   }
 
   /**
@@ -410,11 +414,16 @@ export class DocumentAnalysisClient {
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options: AnalyzeDocumentOptions<LayoutResult> = {}
   ): Promise<AnalysisPoller<LayoutResult>> {
-    return this.createAnalysisPoller(input, {
-      initialModelId: "prebuilt-layout",
+    return this._tracing.withSpan(
+      "DocumentAnalysisClient.beginExtractLayout",
       options,
-      transformResult: (res) => toLayoutResult(toAnalyzeResultFromGenerated(res, identity)),
-    });
+      (finalOptions) =>
+        this.createAnalysisPoller(input, {
+          initialModelId: "prebuilt-layout",
+          options: finalOptions,
+          transformResult: (res) => toLayoutResult(toAnalyzeResultFromGenerated(res, identity)),
+        })
+    );
   }
 
   /**
@@ -486,12 +495,17 @@ export class DocumentAnalysisClient {
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options: AnalyzeDocumentOptions<GeneralDocumentResult> = {}
   ): Promise<AnalysisPoller<GeneralDocumentResult>> {
-    return this.createAnalysisPoller(input, {
-      initialModelId: "prebuilt-document",
+    return this._tracing.withSpan(
+      "DocumentAnalysisClient.beginExtractGeneralDocument",
       options,
-      transformResult: (res) =>
-        toGeneralDocumentResult(toAnalyzeResultFromGenerated(res, identity)),
-    });
+      (finalOptions) =>
+        this.createAnalysisPoller(input, {
+          initialModelId: "prebuilt-document",
+          options: finalOptions,
+          transformResult: (res) =>
+            toGeneralDocumentResult(toAnalyzeResultFromGenerated(res, identity)),
+        })
+    );
   }
 
   /**
@@ -552,11 +566,16 @@ export class DocumentAnalysisClient {
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options: AnalyzeDocumentOptions<ReadResult> = {}
   ): Promise<AnalysisPoller<ReadResult>> {
-    return this.createAnalysisPoller(input, {
-      initialModelId: "prebuilt-read",
+    return this._tracing.withSpan(
+      "DocumentAnalysisClient.beginReadDocument",
       options,
-      transformResult: (res) => toReadResult(toAnalyzeResultFromGenerated(res, identity)),
-    });
+      (finalOptions) =>
+        this.createAnalysisPoller(input, {
+          initialModelId: "prebuilt-read",
+          options: finalOptions,
+          transformResult: (res) => toReadResult(toAnalyzeResultFromGenerated(res, identity)),
+        })
+    );
   }
 
   /**
@@ -578,14 +597,14 @@ export class DocumentAnalysisClient {
     // TODO: what should we do if resumeFrom.modelId is different from initialModelId?
     // And what do we do with the redundant input??
 
-    const getAnalyzeResult = async (operationLocation: string): Promise<AnalyzeResultOperation> =>
+    const getAnalyzeResult = (operationLocation: string): Promise<AnalyzeResultOperation> =>
       this._tracing.withSpan(
-        "DocumentAnalysisClient.createAnalysisPoller-toInit",
+        "DocumentAnalysisClient.createAnalysisPoller-getAnalyzeResult",
         definition.options,
-        (updatedOptions) =>
+        (finalOptions) =>
           this._restClient.sendOperationRequest<AnalyzeResultOperation>(
             {
-              options: updatedOptions,
+              options: finalOptions,
             },
             {
               path: operationLocation,
@@ -608,63 +627,78 @@ export class DocumentAnalysisClient {
     const toInit =
       // If the user gave us a stored token, we'll poll it again
       resumeFrom !== undefined
-        ? async () => {
-            const { operationLocation, modelId } = JSON.parse(resumeFrom) as {
-              operationLocation: string;
-              modelId: string;
-            };
+        ? async () =>
+            this._tracing.withSpan(
+              "DocumentAnalysisClient.createAnalysisPoller-resume",
+              definition.options,
+              async () => {
+                const { operationLocation, modelId } = JSON.parse(resumeFrom) as {
+                  operationLocation: string;
+                  modelId: string;
+                };
 
-            const result = await getAnalyzeResult(operationLocation);
+                const result = await getAnalyzeResult(operationLocation);
 
-            return toDocumentAnalysisPollOperationState(
-              definition,
-              modelId,
-              operationLocation,
-              result
-            );
-          }
+                return toDocumentAnalysisPollOperationState(
+                  definition,
+                  modelId,
+                  operationLocation,
+                  result
+                );
+              }
+            )
         : // Otherwise, we'll start a new operation from the initialModelId
-          async () => {
-            const [contentType, analyzeRequest] = toAnalyzeRequest(input);
+          async () =>
+            this._tracing.withSpan(
+              "DocumentAnalysisClient.createAnalysisPoller-start",
+              definition.options,
+              async () => {
+                const [contentType, analyzeRequest] = toAnalyzeRequest(input);
 
-            const { operationLocation } = await this._restClient.analyzeDocument(
-              definition.initialModelId,
-              contentType as any,
-              {
-                ...definition.options,
-                analyzeRequest,
-              }
-            );
+                const { operationLocation } = await this._restClient.analyzeDocument(
+                  definition.initialModelId,
+                  contentType as any,
+                  {
+                    ...definition.options,
+                    analyzeRequest,
+                  }
+                );
 
-            if (operationLocation === undefined) {
-              throw new Error(
-                "Unable to start analysis operation: no Operation-Location received."
-              );
-            }
+                if (operationLocation === undefined) {
+                  throw new Error(
+                    "Unable to start analysis operation: no Operation-Location received."
+                  );
+                }
 
-            const result = await getAnalyzeResult(operationLocation);
+                const result = await getAnalyzeResult(operationLocation);
 
-            return toDocumentAnalysisPollOperationState(
-              definition,
-              definition.initialModelId,
-              operationLocation,
-              result
+                return toDocumentAnalysisPollOperationState(
+                  definition,
+                  definition.initialModelId,
+                  operationLocation,
+                  result
+                );
+              }
             );
-          };
 
     const poller = await lro<Result, DocumentAnalysisPollOperationState<Result>>(
       {
         init: toInit,
-        poll: async ({ operationLocation, modelId }) => {
-          const result = await getAnalyzeResult(operationLocation);
+        poll: async ({ operationLocation, modelId }) =>
+          this._tracing.withSpan(
+            "DocumentAnalysisClient.createAnalysisPoller-poll",
+            {},
+            async () => {
+              const result = await getAnalyzeResult(operationLocation);
 
-          return toDocumentAnalysisPollOperationState(
-            definition,
-            modelId,
-            operationLocation,
-            result
-          );
-        },
+              return toDocumentAnalysisPollOperationState(
+                definition,
+                modelId,
+                operationLocation,
+                result
+              );
+            }
+          ),
         serialize: ({ operationLocation, modelId }) =>
           JSON.stringify({ modelId, operationLocation }),
       },