Merge pull request #246629 from MicrosoftDocs/repo_sync_working_branch

Confirm merge from repo_sync_working_branch to main to sync with https://github.com/MicrosoftDocs/azure-docs (branch main)

Author: Taojunshen

articles/ai-services/language-service/text-analytics-for-health/includes/quickstarts/csharp-sdk.md

@@ -58,8 +58,8 @@ namespace Example
     class Program
     {
         // This example requires environment variables named "LANGUAGE_KEY" and "LANGUAGE_ENDPOINT"
-        private static readonly AzureKeyCredential credentials = Environment.GetEnvironmentVariable("LANGUAGE_KEY");
-        private static readonly Uri endpoint = Environment.GetEnvironmentVariable("LANGUAGE_ENDPOINT");
+        private static readonly AzureKeyCredential credentials = new (Environment.GetEnvironmentVariable("LANGUAGE_KEY"));
+        private static readonly Uri endpoint = new (Environment.GetEnvironmentVariable("LANGUAGE_ENDPOINT"));
 
         // Example method for extracting information from healthcare-related text 
         static async Task healthExample(TextAnalyticsClient client)

articles/azure-functions/functions-host-json.md

@@ -392,7 +392,7 @@ Controls the logging behaviors of the function app, including Application Insigh
 
 |Property  |Default | Description |
 |---------|---------|---------|
-|fileLoggingMode|debugOnly|Determines the file logging behavior when running in Azure. Options are `never`, `always`, and `debugOnly`. This setting isn't used when running locally. When possible, you should use Application Insights when debugging your functions in Azure. Using `always` negatively impacts your app's cold start behavior and data throughput. The default `debguOnly` setting generates log files when you are debugging using the Azure portal. |
+|fileLoggingMode|debugOnly|Determines the file logging behavior when running in Azure. Options are `never`, `always`, and `debugOnly`. This setting isn't used when running locally. When possible, you should use Application Insights when debugging your functions in Azure. Using `always` negatively impacts your app's cold start behavior and data throughput. The default `debugOnly` setting generates log files when you are debugging using the Azure portal. |
 |logLevel|n/a|Object that defines the log category filtering for functions in the app. This setting lets you filter logging for specific functions. For more information, see [Configure log levels](configure-monitoring.md#configure-log-levels). |
 |console|n/a| The [console](#console) logging setting. |
 |applicationInsights|n/a| The [applicationInsights](#applicationinsights) setting. |

articles/azure-maps/webgl-custom-layer.md

@@ -13,8 +13,8 @@ services: azure-maps
 # Add a custom WebGL layer to a map
 
 The Azure Maps Web SDK supports creating custom layers
-using [WebGL][getting_started_with_webgl]. WebGL is based
-on [OpenGL ES][OpenGL ES] and enables rendering 2D and 3D
+using [WebGL]. WebGL is based
+on [OpenGL ES] and enables rendering 2D and 3D
 graphics in web browsers.
 
 Using WebGL, you can build high-performance interactive
@@ -24,7 +24,7 @@ scenarios like simulations, data visualization, animations and
 
 Developers can access the WebGL context of the map during
 rendering and use custom WebGL layers to integrate with other
-libraries such as [three.js][threejs] and [deck.gl][deckgl]
+libraries such as [three.js] and [deck.gl]
 to provide enriched and interactive content on the map.
 
 ## Add a WebGL layer
@@ -119,12 +119,12 @@ This sample renders a triangle on the map using a WebGL layer.
 
 ![A screenshot showing a triangle rendered on a map, using a WebGL layer.](./media/how-to-webgl-custom-layer/triangle.png)
 
-For a fully functional sample with source code, see [Simple 2D WebGL layer][Simple 2D WebGL layer] in the Azure Maps Samples.
+For a fully functional sample with source code, see [Simple 2D WebGL layer] in the Azure Maps Samples.
 
 The map's camera matrix is used to project spherical Mercator point to
-gl coordinates. Mercator point \[0, 0\] represents the top left corner
+`gl` coordinates. Mercator point \[0, 0\] represents the top left corner
 of the Mercator world and \[1, 1\] represents the bottom right corner.
-When the `renderingMode` is `"3d"`, the z coordinate is conformal.
+When `renderingMode` is `"3d"`, the z coordinate is conformal.
 A box with identical x, y, and z lengths in Mercator units would be
 rendered as a cube.
 
@@ -136,7 +136,7 @@ methods can be used to project a Mercator point to a Position.
 ## Render a 3D model
 
 Use a WebGL layer to render 3D models. The following example shows how
-to load a [glTF][glTF] file and render it on the map using [three.js][threejs].
+to load a [glTF] file and render it on the map using [three.js].
 
 You need to add the following script files.
 
@@ -149,10 +149,10 @@ This sample renders an animated 3D parrot on the map.
 
 ![A screenshot showing an an animated 3D parrot on the map.](./media/how-to-webgl-custom-layer/3d-parrot.gif)
 
-For a fully functional sample with source code, see [Three custom WebGL layer][Three custom WebGL layer] in the Azure Maps Samples.
+For a fully functional sample with source code, see [Three custom WebGL layer] in the Azure Maps Samples.
 
 The `onAdd` function loads a `.glb` file into memory and instantiates
-three.js objects such as Camera, Scene, Light, and a `THREE.WebGLRenderer`.
+[three.js] objects such as Camera, Scene, Light, and a `THREE.WebGLRenderer`.
 
 The `render` function calculates the projection matrix of the camera
 and renders the model to the scene.
@@ -166,7 +166,7 @@ one of the style options while creating the map.
 
 ## Render a 3D model using babylon.js
 
-[Babylon.js][babylonjs] is one of the world's leading WebGL-based graphics engines. The following example shows how to load a GLTF file and render it on the map using babylon.js.
+[Babylon.js] is one of the world's leading WebGL-based graphics engines. The following example shows how to load a GLTF file and render it on the map using babylon.js.
 
 You need to add the following script files.  
 
@@ -183,11 +183,11 @@ The `render` function calculates the projection matrix of the camera and renders
 
 ![A screenshot showing an example of rendering a 3D model using babylon.js.](./media/how-to-webgl-custom-layer/render-3d-model.png)
 
-For a fully functional sample with source code, see [Babylon custom WebGL layer][Babylon custom WebGL layer] in the Azure Maps Samples.
+For a fully functional sample with source code, see [Babylon custom WebGL layer] in the Azure Maps Samples.
 
 ## Render a deck.gl layer
 
-A WebGL layer can be used to render layers from the [deck.gl][deckgl]
+A WebGL layer can be used to render layers from the [deck.gl]
 library. The following sample demonstrates the data visualization of
 people migration flow in the United States from county to county
 within a certain time range.
@@ -230,40 +230,39 @@ class DeckGLLayer extends atlas.layer.WebGLLayer {
 } 
 ```
 
-
-This sample renders an arc-layer google the [deck.gl][deckgl] library.
+This sample renders an arc-layer google the [deck.gl] library.
 
 ![A screenshot showing an arc-layer from the Deck G L library.](./media/how-to-webgl-custom-layer/arc-layer.png)
 
-For a fully functional sample with source code, see [Deck GL custom WebGL layer][Deck GL custom WebGL layer] in the Azure Maps Samples.
+For a fully functional sample with source code, see [Deck GL custom WebGL layer] in the Azure Maps Samples.
 
 ## Next steps
 
 Learn more about the classes and methods used in this article:
 
 > [!div class="nextstepaction"]
-> [WebGLLayer][WebGLLayer]
+> [WebGLLayer]
 
 > [!div class="nextstepaction"]
-> [WebGLLayerOptions][WebGLLayerOptions]
+> [WebGLLayerOptions]
 
 > [!div class="nextstepaction"]
-> [WebGLRenderer interface][WebGLRenderer interface]
+> [WebGLRenderer interface]
 
 > [!div class="nextstepaction"]
-> [MercatorPoint][MercatorPoint]
+> [MercatorPoint]
 
-[getting_started_with_webgl]: https://developer.mozilla.org/en-US/docs/web/api/webgl_api/tutorial/getting_started_with_webgl
-[threejs]: https://threejs.org/
-[deckgl]: https://deck.gl/
+[Babylon custom WebGL layer]: https://samples.azuremaps.com/?sample=babylon-custom-webgl-layer
+[Babylon.js]: https://www.babylonjs.com/
+[Deck GL custom WebGL layer]: https://samples.azuremaps.com/?sample=deck-gl-custom-webgl-layer
+[deck.gl]: https://deck.gl/
 [glTF]: https://www.khronos.org/gltf/
+[MercatorPoint]: /javascript/api/azure-maps-control/atlas.data.mercatorpoint
 [OpenGL ES]: https://www.khronos.org/opengles/
-[babylonjs]: https://www.babylonjs.com/
+[Simple 2D WebGL layer]: https://samples.azuremaps.com/?sample=simple-2d-webgl-layer
+[Three custom WebGL layer]: https://samples.azuremaps.com/?sample=three-custom-webgl-layer
+[three.js]: https://threejs.org/
+[WebGL]: https://developer.mozilla.org/en-US/docs/web/api/webgl_api/tutorial/getting_started_with_webgl
 [WebGLLayer]: /javascript/api/azure-maps-control/atlas.layer.webgllayer
 [WebGLLayerOptions]: /javascript/api/azure-maps-control/atlas.webgllayeroptions
 [WebGLRenderer interface]: /javascript/api/azure-maps-control/atlas.webglrenderer
-[MercatorPoint]: /javascript/api/azure-maps-control/atlas.data.mercatorpoint
-[Simple 2D WebGL layer]: https://samples.azuremaps.com/?sample=simple-2d-webgl-layer
-[Deck GL custom WebGL layer]: https://samples.azuremaps.com/?sample=deck-gl-custom-webgl-layer
-[Three custom WebGL layer]: https://samples.azuremaps.com/?sample=three-custom-webgl-layer
-[Babylon custom WebGL layer]: https://samples.azuremaps.com/?sample=babylon-custom-webgl-layer

articles/azure-maps/zoom-levels-and-tile-grid.md

@@ -12,10 +12,10 @@ services: azure-maps
 
 # Zoom levels and tile grid
 
-Azure Maps use the Spherical Mercator projection coordinate system (EPSG: 3857). A projection is the mathematical model used to transform the spherical globe into a flat map. The Spherical Mercator projection stretches the map at the poles to create a square map. This projection significantly distorts the scale and area of the map but has two important properties that outweigh this distortion:
+Azure Maps use the Spherical Mercator projection coordinate system ([EPSG:3857]). A projection is the mathematical model used to transform the spherical globe into a flat map. The Spherical Mercator projection stretches the map at the poles to create a square map. This projection significantly distorts the scale and area of the map but has two important properties that outweigh this distortion:
 
 - It's a conformal projection, which means that it preserves the shape of relatively small objects. Preserving the shape of small objects is especially important when showing aerial imagery. For example, we want to avoid distorting the shape of buildings. Square buildings should appear square, not rectangular.
-- It's a cylindrical projection. North and south are always up and down, and west and east are always left and right. 
+- It's a cylindrical projection. North and south are always up and down, and west and east are always left and right.
 
 To optimize the performance of map retrieval and display, the map is divided into square tiles. The Azure Maps SDK's use tiles that have a size of 512 x 512 pixels for road maps, and smaller 256 x 256 pixels for satellite imagery. Azure Maps provides raster and vector tiles for 23 zoom levels, numbered 0 through 22. At zoom level 0, the entire world fits on a single tile:
 
@@ -27,7 +27,7 @@ Zoom level 1 uses four tiles to render the world: a 2 x 2 square
 
 Each additional zoom level quad-divides the tiles of the previous one, creating a grid of 2<sup>zoom</sup> x 2<sup>zoom</sup>. Zoom level 22 is a grid 2<sup>22</sup> x 2<sup>22</sup>, or 4,194,304 x 4,194,304 tiles (17,592,186,044,416 tiles in total).
 
-The Azure Maps interactive map controls for web and Android support 25 zoom levels, numbered 0 through 24. Although road data will only be available at the zoom levels in when the tiles are available.
+The Azure Maps interactive map controls for web and Android support 25 zoom levels, numbered 0 through 24. Although road data is only available at the zoom levels in when the tiles are available.
 
 The following table provides the full list of values for zoom levels where the tile size is **512** pixels square at latitude 0:
 
@@ -115,16 +115,16 @@ When determining which zoom level to use, remember each location is in a fixed p
 
 Once the zoom level is determined, the x and y values can be calculated. The top-left tile in each zoom grid is x=0, y=0; the bottom-right tile is at x=2<sup>zoom-1</sup>, y=2<sup>zoom-1</sup>.
 
-Here is the zoom grid for zoom level 1:
+Here's the zoom grid for zoom level 1:
 
 :::image type="content" border="false" source="./media/zoom-levels-and-tile-grid/api_x_y.png" alt-text="Zoom grid for zoom level 1":::
 
 ## Quadkey indices
 
-Some mapping platforms use a `quadkey` indexing naming convention that combines the tile ZY coordinates into a one-dimension string called `quadtree` keys or `quadkeys` for short. Each `quadkey` uniquely identifies a single tile at a particular level of detail, and it can be used as a key in common database B-tree indexes. The Azure Maps SDKs support the overlaying of tile layers that use `quadkey` naming convention in addition to other naming conventions as documented in the [Add a tile layer](map-add-tile-layer.md) document.
+Some mapping platforms use a `quadkey` indexing naming convention that combines the tile ZY coordinates into a one-dimension string called `quadtree` keys or `quadkeys` for short. Each `quadkey` uniquely identifies a single tile at a particular level of detail, and it can be used as a key in common database B-tree indexes. The Azure Maps SDKs support the overlaying of tile layers that use `quadkey` naming convention in addition to other naming conventions as documented in the [Add a tile layer] document.
 
 > [!NOTE]
-> The `quadkeys` naming convention only works for zoom levels of one or greater. The Azure Maps SDK's support zoom level 0 which is a single map tile for the whole world. 
+> The `quadkeys` naming convention only works for zoom levels of one or greater. The Azure Maps SDK's support zoom level 0 which is a single map tile for the whole world.
 
 To convert tile coordinates into a `quadkey`, the bits of the Y and X coordinates are interleaved, and the result is interpreted as a base-4 number (with leading zeros maintained) and converted into a string. For instance, given tile XY coordinates of (3, 5) at level 3, the `quadkey` is determined as follows:
 
@@ -136,7 +136,7 @@ tileY = 5 = 101 (base 2)
 quadkey = 100111 (base 2) = 213 (base 4) = "213"
 ```
 
-`Qquadkeys` have several interesting properties. First, the length of a `quadkey` (the number of digits) equals the zoom level of the corresponding tile. Second, the `quadkey` of any tile starts with the `quadkey` of its parent tile (the containing tile at the previous level). As shown in the example below, tile 2 is the parent of tiles 20 through 23:
+`Qquadkeys` have several interesting properties. First, the length of a `quadkey` (the number of digits) equals the zoom level of the corresponding tile. Second, the `quadkey` of any tile starts with the `quadkey` of its parent tile (the containing tile at the previous level). As shown in the following example, tile 2 is the parent of tiles 20 through 23:
 
 :::image type="content" border="false" source="./media/zoom-levels-and-tile-grid/quadkey-tile-pyramid.png" alt-text="Quadkey tile pyramid":::
 
@@ -927,23 +927,32 @@ module AzureMaps {
 * * *
 
 > [!NOTE]
-> The interactive map controls in the Azure Maps SDK's have helper functions for converting between geospatial positions and viewport pixels. 
-> - [Web SDK: Map pixel and position calculations](/javascript/api/azure-maps-control/atlas.map#pixelstopositions-pixel---)
+> The interactive map controls in the Azure Maps SDK's have helper functions for converting between geospatial positions and viewport pixels.
+>
+> - [Web SDK: Map pixel and position calculations]
 
 ## Next steps
 
 Directly access map tiles from the Azure Maps REST services:
 
 > [!div class="nextstepaction"]
-> [Get map tiles](/rest/api/maps/render/getmaptile)
+> [Get map tiles]
 
 > [!div class="nextstepaction"]
-> [Get traffic flow tiles](/rest/api/maps/traffic/gettrafficflowtile)
+> [Get traffic flow tiles]
 
 > [!div class="nextstepaction"]
-> [Get traffic incident tiles](/rest/api/maps/traffic/gettrafficincidenttile)
+> [Get traffic incident tiles]
 
 Learn more about geospatial concepts:
 
 > [!div class="nextstepaction"]
-> [Azure Maps glossary](glossary.md)
+> [Azure Maps glossary]
+
+[EPSG:3857]: https://epsg.io/3857
+[Web SDK: Map pixel and position calculations]: /javascript/api/azure-maps-control/atlas.map#pixelstopositions-pixel---
+[Add a tile layer]: map-add-tile-layer.md
+[Get map tiles]: /rest/api/maps/render/getmaptile
+[Get traffic flow tiles]: /rest/api/maps/traffic/gettrafficflowtile
+[Get traffic incident tiles]: /rest/api/maps/traffic/gettrafficincidenttile
+[Azure Maps glossary]: glossary.md

articles/azure-monitor/app/opentelemetry-add-modify.md

@@ -292,7 +292,7 @@ The following table represents the currently supported custom telemetry types:
 |-------------------------------------------|---------------|----------------|--------------|------------|------------|----------|--------|
 | **ASP.NET Core**                          |               |                |              |            |            |          |        |
 |    OpenTelemetry API       |               | Yes            | Yes          | Yes        |            | Yes      |        |
-|    iLogger API             |               |                |              |            |            |          | Yes    |
+|    ILogger API             |               |                |              |            |            |          | Yes    |
 |    AI Classic API          |               |                |              |            |            |          |        |
 |                                           |               |                |              |            |            |          |        |
 | **Java**                                  |               |                |              |            |            |          |        |