Merge branch 'main' into trace-based-sampling

Author: rads-1996

eng/common/instructions/azsdk-tools/create-release-plan.instructions.md

@@ -1,7 +1,8 @@
-> **Important Note for LLM**
-> Backend processes may use Azure DevOps work item data as needed. However, do **not** mention or display the work item link/URL, or any reference to Azure DevOps work item resources directly in conversation with the user.
-> All manual updates to an existing release plan must be made through the [Release Planner Tool](https://aka.ms/sdk-release-planner) to ensure proper tracking and validation.
-> Only provide release plan details such as **Release Plan Link** and **Release Plan ID** to the user
+> **CRITICAL INSTRUCTIONS FOR LLM**
+> 1. Backend processes may use Azure DevOps work item data as needed. However, do **not** mention or display the work item link/URL, or any reference to Azure DevOps work item resources directly in conversation with the user.
+> 2. All manual updates to an existing release plan must be made through the [Release Planner Tool](https://aka.ms/sdk-release-planner) to ensure proper tracking and validation.
+> 3. Only provide release plan details such as **Release Plan Link** and **Release Plan ID** to the user
+> 4. Always check the `NextSteps` field in the tool response and follow any additional prompts provided. Do NOT proceed to other steps until the NextSteps are completed.
 
 # Release Plan Creation Process
 Your goal is to create a valid release plan. You must prompt user to provide all required information and all input must match the format and requirement mentioned in step 3 below.
@@ -12,12 +13,14 @@ Follow these steps in order to create or manage a release plan for an API specif
 - If no pull request is available, prompt the user to provide the API spec pull request link
 - Validate that the provided pull request link is accessible and valid
 
-## Step 2: Check Existing Release Plan
-- Use `azsdk_get_release_plan_for_spec_pr` to check if a release plan already exists for the API spec pull request
-- If a release plan exists:
-    - Display the existing release plan details to the user
-    - Skip to Step 5 (Link SDK Pull Requests)
-- If no release plan exists, proceed to Step 3
+## Step 2: Check for Existing Release Plan
+- Ask the user if they already have an existing release plan
+- If they confirm:
+    - Query the existing release plan using either:
+        - The release plan number, or
+        - The API spec pull request link
+    - Display the existing release plan details (Release Plan ID, status, associated languages, SDK PRs).
+- If no existing release plan is found, continue to Step 3 to gather required details for creating a new one. 
 
 ## Step 3: Gather Release Plan Information
 Collect the following required information from the user. Do not create a release plan with temporary values. Confirm the values with the user before proceeding to create the release plan.
@@ -35,6 +38,7 @@ If any details are missing, prompt the user accordingly:
 - If the user doesn't know the required details, direct them to create a release plan using the release planner
 - Provide this resource: [Release Plan Creation Guide](https://eng.ms/docs/products/azure-developer-experience/plan/release-plan-create)
 - Once all information is gathered, use `azsdk_create_release_plan` to create the release plan
+- If existing release plans are found, extract and display key information: Release Plan ID, status, associated languages, SDK PRs
 - Display the newly created release plan details to the user for confirmation
 - Refer to #file:sdk-details-in-release-plan.instructions.md to identify languages configured in the TypeSpec project and add them to the release plan
 

eng/tools/azure-sdk-tools/ci_tools/dependency_analysis.py

@@ -58,7 +58,7 @@ def record_dep(dependencies: Dict[str, Dict[str, Any]], req_name: str, spec: str
 def get_lib_deps(base_dir: str) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Dict[str, Any]]]:
     packages = {}
     dependencies = {}
-    for lib_dir in discover_targeted_packages("azure*", base_dir):
+    for lib_dir in discover_targeted_packages("azure*", base_dir, compatibility_filter=False):
         try:
             parsed = ParsedSetup.from_path(lib_dir)
             lib_name, version, requires = parsed.name, parsed.version, parsed.requires

eng/tools/azure-sdk-tools/ci_tools/functions.py

@@ -104,7 +104,7 @@ def unzip_file_to_directory(path_to_zip_file: str, extract_location: str) -> str
             return os.path.join(extract_location, extracted_dir)
 
 
-def apply_compatibility_filter(package_set: List[str]) -> List[str]:
+def apply_compatibility_filter(package_set: List[ParsedSetup]) -> List[ParsedSetup]:
     """
     This function takes in a set of paths to python packages. It returns the set filtered by compatibility with the currently running python executable.
     If a package is unsupported by the executable, it will be omitted from the returned list.
@@ -118,28 +118,25 @@ def apply_compatibility_filter(package_set: List[str]) -> List[str]:
     running_major_version = Version(".".join([str(v[0]), str(v[1]), str(v[2])]))
 
     for pkg in package_set:
-        try:
-            spec_set = SpecifierSet(ParsedSetup.from_path(pkg).python_requires)
-        except RuntimeError as e:
-            logging.error(f"Unable to parse metadata for package {pkg}, omitting from build.")
-            continue
+        spec_set = SpecifierSet(pkg.python_requires)
 
-        pkg_specs_override = TEST_COMPATIBILITY_MAP.get(os.path.basename(pkg), None)
+        pkg_specs_override = TEST_COMPATIBILITY_MAP.get(pkg.name, None)
 
         if pkg_specs_override:
             spec_set = SpecifierSet(pkg_specs_override)
 
         distro_compat = True
-        distro_incompat = TEST_PYTHON_DISTRO_INCOMPATIBILITY_MAP.get(os.path.basename(pkg), None)
+        distro_incompat = TEST_PYTHON_DISTRO_INCOMPATIBILITY_MAP.get(pkg.name, None)
         if distro_incompat and distro_incompat in platform.python_implementation().lower():
             distro_compat = False
 
         if running_major_version in spec_set and distro_compat:
             collected_packages.append(pkg)
 
-    logging.debug("Target packages after applying compatibility filter: {}".format(collected_packages))
     logging.debug(
-        "Package(s) omitted by compatibility filter: {}".format(generate_difference(package_set, collected_packages))
+        "Package(s) omitted by compatibility filter: {}".format(
+            generate_difference([origpkg.name for origpkg in package_set], [pkg.name for pkg in collected_packages])
+        )
     )
 
     return collected_packages
@@ -208,12 +205,17 @@ def glob_packages(glob_string: str, target_root_dir: str) -> List[str]:
     return list(set(collected_top_level_directories))
 
 
-def apply_business_filter(collected_packages: List[str], filter_type: str) -> List[str]:
-    pkg_set_ci_filtered = list(filter(omit_function_dict.get(filter_type, omit_build), collected_packages))
+def apply_business_filter(collected_packages: List[ParsedSetup], filter_type: str) -> List[ParsedSetup]:
+    pkg_set_ci_filtered = []
+
+    for pkg in collected_packages:
+        if omit_function_dict.get(filter_type, omit_build)(pkg.folder):
+            pkg_set_ci_filtered.append(pkg)
 
-    logging.debug("Target packages after applying business filter: {}".format(pkg_set_ci_filtered))
     logging.debug(
-        "Package(s) omitted by business filter: {}".format(generate_difference(collected_packages, pkg_set_ci_filtered))
+        "Package(s) omitted by business filter: {}".format(
+            generate_difference([pkg.name for pkg in collected_packages], [pkg.name for pkg in pkg_set_ci_filtered])
+        )
     )
 
     return pkg_set_ci_filtered
@@ -248,41 +250,54 @@ def discover_targeted_packages(
         f'Results for glob_string "{glob_string}" and root directory "{target_root_dir}" are: {collected_packages}'
     )
 
-    # apply the additional contains filter
+    # apply the additional contains filter (purely string based)
     collected_packages = [pkg for pkg in collected_packages if additional_contains_filter in pkg]
     logger.debug(f'Results after additional contains filter: "{additional_contains_filter}" {collected_packages}')
 
+    # now the have the initial package set, we need to walk the set and attempt to parse_setup each package
+    # this will have the impact of cleaning out any packages that have been set to not buildable anymore (EG namespace packages)
+    parsed_packages = []
+    for pkg in collected_packages:
+        try:
+            parsed_packages.append(ParsedSetup.from_path(pkg))
+        except RuntimeError as e:
+            logging.error(f"Unable to parse metadata for package {pkg}, omitting from build.")
+            continue
+
     # filter for compatibility, this means excluding a package that doesn't support py36 when we are running a py36 executable
     if compatibility_filter:
-        collected_packages = apply_compatibility_filter(collected_packages)
-        logger.debug(f"Results after compatibility filter: {collected_packages}")
+        parsed_packages = apply_compatibility_filter(parsed_packages)
+        logger.debug(f"Results after compatibility filter: {','.join([p.name for p in parsed_packages])}")
 
     if not include_inactive:
-        collected_packages = apply_inactive_filter(collected_packages)
+        parsed_packages = apply_inactive_filter(parsed_packages)
 
     # Apply filter based on filter type. for e.g. Docs, Regression, Management
-    collected_packages = apply_business_filter(collected_packages, filter_type)
-    logger.debug(f"Results after business filter: {collected_packages}")
+    parsed_packages = apply_business_filter(parsed_packages, filter_type)
+    logger.debug(f"Results after business filter: {[pkg.name for pkg in parsed_packages]}")
 
-    return sorted(collected_packages)
+    return sorted([pkg.folder for pkg in parsed_packages])
 
 
-def is_package_active(package_path: str):
-    disabled = INACTIVE_CLASSIFIER in ParsedSetup.from_path(package_path).classifiers
+def is_package_active(pkg: ParsedSetup) -> bool:
+    disabled = INACTIVE_CLASSIFIER in pkg.classifiers
 
-    override_value = os.getenv(f"ENABLE_{os.path.basename(package_path).upper().replace('-', '_')}", None)
+    override_value = os.getenv(f"ENABLE_{pkg.name.upper().replace('-', '_')}", None)
 
     if override_value:
         return str_to_bool(override_value)
     else:
         return not disabled
 
 
-def apply_inactive_filter(collected_packages: List[str]) -> List[str]:
+def apply_inactive_filter(collected_packages: List[ParsedSetup]) -> List[ParsedSetup]:
     packages = [pkg for pkg in collected_packages if is_package_active(pkg)]
 
-    logging.debug("Target packages after applying inactive filter: {}".format(collected_packages))
-    logging.debug("Package(s) omitted by inactive filter: {}".format(generate_difference(collected_packages, packages)))
+    logging.debug(
+        "Package(s) omitted by inactive filter: {}".format(
+            generate_difference([collected.name for collected in collected_packages], [pkg.name for pkg in packages])
+        )
+    )
 
     return packages
 

sdk/ai/azure-ai-projects/azure/ai/projects/telemetry/_ai_project_instrumentor.py

@@ -431,15 +431,20 @@ def _add_instructions_event(
         agent_id: Optional[str] = None,
         thread_id: Optional[str] = None,
     ) -> None:
+        # Early return if no instructions to trace
         if not instructions:
             return
 
         event_body: Dict[str, Any] = {}
-        if _trace_agents_content and (instructions or additional_instructions):
-            if instructions and additional_instructions:
-                event_body["text"] = f"{instructions} {additional_instructions}"
+        if _trace_agents_content:
+            # Combine instructions if both exist
+            if additional_instructions:
+                combined_text = f"{instructions} {additional_instructions}"
             else:
-                event_body["text"] = instructions or additional_instructions
+                combined_text = instructions
+
+            # Use standard content format
+            event_body["content"] = [{"type": "text", "text": combined_text}]
 
         attributes = self._create_event_attributes(agent_id=agent_id, thread_id=thread_id)
         attributes[GEN_AI_EVENT_CONTENT] = json.dumps(event_body, ensure_ascii=False)
@@ -481,6 +486,8 @@ def start_create_agent_span(  # pylint: disable=too-many-locals
         reasoning_summary: Optional[str] = None,
         text: Optional[Any] = None,  # pylint: disable=unused-argument
         structured_inputs: Optional[Any] = None,
+        agent_type: Optional[str] = None,
+        workflow_yaml: Optional[str] = None,
     ) -> "Optional[AbstractSpan]":
         span = start_span(
             OperationName.CREATE_AGENT,
@@ -501,8 +508,19 @@ def start_create_agent_span(  # pylint: disable=too-many-locals
                 span.add_attribute(GEN_AI_AGENT_NAME, name)
             if description:
                 span.add_attribute(GEN_AI_AGENT_DESCRIPTION, description)
+            if agent_type:
+                span.add_attribute("gen_ai.agent.type", agent_type)
+
+            # Add instructions event (if instructions exist)
             self._add_instructions_event(span, instructions, None)
 
+            # Add workflow YAML as event if content recording is enabled and workflow exists
+            if _trace_agents_content and workflow_yaml:
+                event_body: Dict[str, Any] = {"content": [{"type": "workflow", "workflow": workflow_yaml}]}
+                attributes = self._create_event_attributes()
+                attributes[GEN_AI_EVENT_CONTENT] = json.dumps(event_body, ensure_ascii=False)
+                span.span_instance.add_event(name="gen_ai.agent.workflow", attributes=attributes)
+
         return span
 
     def start_create_thread_span(
@@ -543,7 +561,7 @@ def get_server_address_from_arg(self, arg: Any) -> Optional[Tuple[str, Optional[
 
     def _create_agent_span_from_parameters(
         self, *args, **kwargs
-    ):  # pylint: disable=too-many-statements,too-many-locals,docstring-missing-param
+    ):  # pylint: disable=too-many-statements,too-many-locals,too-many-branches,docstring-missing-param
         """Extract parameters and create span for create_agent tracing."""
         server_address_info = self.get_server_address_from_arg(args[0])
         server_address = server_address_info[0] if server_address_info else None
@@ -567,8 +585,23 @@ def _create_agent_span_from_parameters(
         structured_inputs = None
         description = definition.get("description")
         tool_resources = definition.get("tool_resources")
+        workflow_yaml = definition.get("workflow")  # Extract workflow YAML for workflow agents
         # toolset = definition.get("toolset")
 
+        # Determine agent type from definition
+        # Check for workflow first (most specific)
+        agent_type = None
+        if workflow_yaml:
+            agent_type = "workflow"
+        elif instructions or model:
+            # Prompt agent - identified by having instructions and/or a model.
+            # Note: An agent with only a model (no instructions) is treated as a prompt agent,
+            # though this is uncommon. Typically prompt agents have both model and instructions.
+            agent_type = "prompt"
+        else:
+            # Unknown type - set to "unknown" to indicate we couldn't determine it
+            agent_type = "unknown"
+
         # Extract reasoning effort and summary from reasoning if available
         reasoning_effort = None
         reasoning_summary = None
@@ -645,6 +678,8 @@ def _create_agent_span_from_parameters(
             reasoning_summary=reasoning_summary,
             text=text,
             structured_inputs=structured_inputs,
+            agent_type=agent_type,
+            workflow_yaml=workflow_yaml,
         )
 
     def trace_create_agent(self, function, *args, **kwargs):