diff --git a/.github/actions/create_workflow_report/ci_run_report.html.jinja b/.github/actions/create_workflow_report/ci_run_report.html.jinja
index 7a8a91c4ff29..a92c1aa34e3a 100644
--- a/.github/actions/create_workflow_report/ci_run_report.html.jinja
+++ b/.github/actions/create_workflow_report/ci_run_report.html.jinja
@@ -150,6 +150,10 @@
         <th class="hth no-sort">Commit</th>
         <td><a href="https://github.com/{{ github_repo }}/commit/{{ commit_sha }}">{{ commit_sha }}</a></td>
       </tr>
+      <tr>
+        <th class="hth no-sort">Build Report</th>
+        <td><a href="https://s3.amazonaws.com/{{ s3_bucket }}/{{ pr_number }}/{{ commit_sha }}/builds/report.html">Build Report</a></td>
+      </tr>
       <tr>
         <th class="hth no-sort">Date</th>
         <td> {{ date }}</td>
@@ -161,6 +165,7 @@
   {% endif %}
   <h2>Table of Contents</h2>
   <ul>
+    {%- if pr_number != 0 %}<li><a href="#new-fails-pr">New Fails in PR</a> ({{ counts.pr_new_fails }})</li>{% endif %}
     <li><a href="#ci-jobs-status">CI Jobs Status</a> ({{ counts.jobs_status }})</li>
     <li><a href="#checks-errors">Checks Errors</a> ({{ counts.checks_errors }})</li>
     <li><a href="#checks-fails">Checks New Fails</a> ({{ counts.checks_new_fails }})</li>
@@ -169,6 +174,12 @@
     <li><a href="#checks-known-fails">Checks Known Fails</a> ({{ counts.checks_known_fails }})</li>
   </ul>
 
+  {%- if pr_number != 0 -%}
+  <h2 id="new-fails-pr">New Fails in PR</h2>
+  <p> Compared with base sha {{ base_sha }} </p>
+  {{ new_fails_html }}
+  {%- endif %}
+
   <h2 id="ci-jobs-status">CI Jobs Status</h2>
   {{ ci_jobs_status_html }}
 
@@ -185,6 +196,12 @@
   {{ docker_images_cves_html }}
 
   <h2 id="checks-known-fails">Checks Known Fails</h2>
+  <p>
+    Fail reason conventions:<br/>
+    KNOWN - Accepted fail and fix is not planned<br/>
+    INVESTIGATE - We don't know why it fails<br/>
+    NEEDSFIX - Investigation done and a fix is needed to make it pass<br/>
+  </p>
   {{ checks_known_fails_html }}
 
   <script>
diff --git a/.github/actions/create_workflow_report/create_workflow_report.py b/.github/actions/create_workflow_report/create_workflow_report.py
index ceaac52b57e1..eca0d9dac7b6 100755
--- a/.github/actions/create_workflow_report/create_workflow_report.py
+++ b/.github/actions/create_workflow_report/create_workflow_report.py
@@ -5,6 +5,7 @@
 from itertools import combinations
 import json
 from datetime import datetime
+from functools import lru_cache
 
 import pandas as pd
 from jinja2 import Environment, FileSystemLoader
@@ -124,6 +125,7 @@ def get_pr_info_from_number(pr_number: str) -> dict:
     return response.json()
 
 
+@lru_cache
 def get_run_details(run_url: str) -> dict:
     """
     Fetch run details for a given run URL.
@@ -151,13 +153,23 @@ def get_checks_fails(client: Client, job_url: str):
     Get tests that did not succeed for the given job URL.
     Exclude checks that have status 'error' as they are counted in get_checks_errors.
     """
-    columns = "check_status as job_status, check_name as job_name, test_status, test_name, report_url as results_link"
-    query = f"""SELECT {columns} FROM `gh-data`.checks
-                WHERE task_url LIKE '{job_url}%'
-                AND test_status IN ('FAIL', 'ERROR')
-                AND check_status!='error'
-                ORDER BY check_name, test_name
-                """
+    query = f"""SELECT job_status, job_name, status as test_status, test_name, results_link
+            FROM (
+                SELECT
+                    argMax(check_status, check_start_time) as job_status,
+                    check_name as job_name,
+                    argMax(test_status, check_start_time) as status,
+                    test_name,
+                    report_url as results_link,
+                    task_url
+                FROM `gh-data`.checks
+                GROUP BY check_name, test_name, report_url, task_url
+            )
+            WHERE task_url LIKE '{job_url}%'
+            AND test_status IN ('FAIL', 'ERROR')
+            AND job_status!='error'
+            ORDER BY job_name, test_name
+            """
     return client.query_dataframe(query)
 
 
@@ -165,14 +177,26 @@ def get_checks_known_fails(client: Client, job_url: str, known_fails: dict):
     """
     Get tests that are known to fail for the given job URL.
     """
-    assert len(known_fails) > 0, "cannot query the database with empty known fails"
-    columns = "check_status as job_status, check_name as job_name, test_status, test_name, report_url as results_link"
-    query = f"""SELECT {columns} FROM `gh-data`.checks
-                WHERE task_url LIKE '{job_url}%'
-                AND test_status='BROKEN'
-                AND test_name IN ({','.join(f"'{test}'" for test in known_fails.keys())})
-                ORDER BY test_name, check_name
-                """
+    if len(known_fails) == 0:
+        return pd.DataFrame()
+
+    query = f"""SELECT job_status, job_name, status as test_status, test_name, results_link
+        FROM (
+            SELECT
+                argMax(check_status, check_start_time) as job_status,
+                check_name as job_name,
+                argMax(test_status, check_start_time) as status,
+                test_name,
+                report_url as results_link,
+                task_url
+            FROM `gh-data`.checks
+            GROUP BY check_name, test_name, report_url, task_url
+        )
+        WHERE task_url LIKE '{job_url}%'
+        AND test_status='BROKEN'
+        AND test_name IN ({','.join(f"'{test}'" for test in known_fails.keys())})
+        ORDER BY job_name, test_name
+        """
 
     df = client.query_dataframe(query)
 
@@ -193,12 +217,22 @@ def get_checks_errors(client: Client, job_url: str):
     """
     Get checks that have status 'error' for the given job URL.
     """
-    columns = "check_status as job_status, check_name as job_name, test_status, test_name, report_url as results_link"
-    query = f"""SELECT {columns} FROM `gh-data`.checks
-                WHERE task_url LIKE '{job_url}%'
-                AND check_status=='error'
-                ORDER BY check_name, test_name
-                """
+    query = f"""SELECT job_status, job_name, status as test_status, test_name, results_link
+            FROM (
+                SELECT
+                    argMax(check_status, check_start_time) as job_status,
+                    check_name as job_name,
+                    argMax(test_status, check_start_time) as status,
+                    test_name,
+                    report_url as results_link,
+                    task_url
+                FROM `gh-data`.checks
+                GROUP BY check_name, test_name, report_url, task_url
+            )
+            WHERE task_url LIKE '{job_url}%'
+            AND job_status=='error'
+            ORDER BY job_name, test_name
+            """
     return client.query_dataframe(query)
 
 
@@ -231,14 +265,14 @@ def get_regression_fails(client: Client, job_url: str):
                     architecture as arch,
                     test_name,
                     argMax(result, start_time) AS status,
-                    job_url,
                     job_name,
-                    report_url as results_link
+                    report_url as results_link,
+                    job_url
                FROM `gh-data`.clickhouse_regression_results
                GROUP BY architecture, test_name, job_url, job_name, report_url
                ORDER BY length(test_name) DESC
             )
-            WHERE job_url='{job_url}'
+            WHERE job_url LIKE '{job_url}%'
             AND status IN ('Fail', 'Error')
             """
     df = client.query_dataframe(query)
@@ -247,6 +281,99 @@ def get_regression_fails(client: Client, job_url: str):
     return df
 
 
+def get_new_fails_this_pr(
+    client: Client,
+    pr_info: dict,
+    checks_fails: pd.DataFrame,
+    regression_fails: pd.DataFrame,
+):
+    """
+    Get tests that failed in the PR but passed in the base branch.
+    Compares both checks and regression test results.
+    """
+    base_sha = pr_info.get("base", {}).get("sha")
+    if not base_sha:
+        raise Exception("No base SHA found for PR")
+
+    # Modify tables to have the same columns
+    if len(checks_fails) > 0:
+        checks_fails = checks_fails.copy().drop(columns=["job_status"])
+    if len(regression_fails) > 0:
+        regression_fails = regression_fails.copy()
+        regression_fails["job_name"] = regression_fails.apply(
+            lambda row: f"{row['arch']} {row['job_name']}".strip(), axis=1
+        )
+        regression_fails["test_status"] = regression_fails["status"]
+
+    # Combine both types of fails and select only desired columns
+    desired_columns = ["job_name", "test_name", "test_status", "results_link"]
+    all_pr_fails = pd.concat([checks_fails, regression_fails], ignore_index=True)[
+        desired_columns
+    ]
+    if len(all_pr_fails) == 0:
+        return pd.DataFrame()
+
+    # Get all checks from the base branch that didn't fail
+    base_checks_query = f"""SELECT job_name, status as test_status, test_name, results_link
+            FROM (
+                SELECT
+                    check_name as job_name,
+                    argMax(test_status, check_start_time) as status,
+                    test_name,
+                    report_url as results_link,
+                    task_url
+                FROM `gh-data`.checks
+                WHERE commit_sha='{base_sha}'
+                GROUP BY check_name, test_name, report_url, task_url
+            )
+            WHERE test_status NOT IN ('FAIL', 'ERROR')
+            ORDER BY job_name, test_name
+            """
+    base_checks = client.query_dataframe(base_checks_query)
+
+    # Get regression results from base branch that didn't fail
+    base_regression_query = f"""SELECT arch, job_name, status, test_name, results_link
+            FROM (
+               SELECT
+                    architecture as arch,
+                    test_name,
+                    argMax(result, start_time) AS status,
+                    job_url,
+                    job_name,
+                    report_url as results_link
+               FROM `gh-data`.clickhouse_regression_results
+               WHERE results_link LIKE'%/{base_sha}/%'
+               GROUP BY architecture, test_name, job_url, job_name, report_url
+               ORDER BY length(test_name) DESC
+            )
+            WHERE status NOT IN ('Fail', 'Error')
+            """
+    base_regression = client.query_dataframe(base_regression_query)
+    if len(base_regression) > 0:
+        base_regression["job_name"] = base_regression.apply(
+            lambda row: f"{row['arch']} {row['job_name']}".strip(), axis=1
+        )
+        base_regression["test_status"] = base_regression["status"]
+        base_regression = base_regression.drop(columns=["arch", "status"])
+
+    # Combine base results
+    base_results = pd.concat([base_checks, base_regression], ignore_index=True)
+
+    # Find tests that failed in PR but passed in base
+    pr_failed_tests = set(zip(all_pr_fails["job_name"], all_pr_fails["test_name"]))
+    base_passed_tests = set(zip(base_results["job_name"], base_results["test_name"]))
+
+    new_fails = pr_failed_tests.intersection(base_passed_tests)
+
+    # Filter PR results to only include new fails
+    mask = all_pr_fails.apply(
+        lambda row: (row["job_name"], row["test_name"]) in new_fails, axis=1
+    )
+    new_fails_df = all_pr_fails[mask]
+
+    return new_fails_df
+
+
 def get_cves(pr_number, commit_sha):
     """
     Fetch Grype results from S3.
@@ -304,7 +431,7 @@ def get_cves(pr_number, commit_sha):
 def url_to_html_link(url: str) -> str:
     if not url:
         return ""
-    text = url.split("/")[-1]
+    text = url.split("/")[-1].replace("__", "_")
     if not text:
         text = "results"
     return f'<a href="{url}">{text}</a>'
@@ -312,7 +439,7 @@ def url_to_html_link(url: str) -> str:
 
 def format_test_name_for_linewrap(text: str) -> str:
     """Tweak the test name to improve line wrapping."""
-    return text.replace(".py::", "/")
+    return f'<span style="line-break: anywhere;">{text}</span>'
 
 
 def format_test_status(text: str) -> str:
@@ -400,6 +527,7 @@ def main():
         "job_statuses": get_commit_statuses(args.commit_sha),
         "checks_fails": get_checks_fails(db_client, args.actions_run_url),
         "checks_known_fails": [],
+        "pr_new_fails": [],
         "checks_errors": get_checks_errors(db_client, args.actions_run_url),
         "regression_fails": get_regression_fails(db_client, args.actions_run_url),
         "docker_images_cves": (
@@ -427,13 +555,21 @@ def main():
             )
 
     if args.pr_number == 0:
-        pr_info_html = "Release"
+        run_details = get_run_details(args.actions_run_url)
+        branch_name = run_details.get("head_branch", "unknown branch")
+        pr_info_html = f"Release ({branch_name})"
     else:
         try:
             pr_info = get_pr_info_from_number(args.pr_number)
             pr_info_html = f"""<a href="https://github.com/{GITHUB_REPO}/pull/{pr_info["number"]}">
                     #{pr_info.get("number")} ({pr_info.get("base", {}).get('ref')} <- {pr_info.get("head", {}).get('ref')})  {pr_info.get("title")}
                     </a>"""
+            fail_results["pr_new_fails"] = get_new_fails_this_pr(
+                db_client,
+                pr_info,
+                fail_results["checks_fails"],
+                fail_results["regression_fails"],
+            )
         except Exception as e:
             pr_info_html = e
 
@@ -450,9 +586,12 @@ def main():
     context = {
         "title": "ClickHouse® CI Workflow Run Report",
         "github_repo": GITHUB_REPO,
+        "s3_bucket": S3_BUCKET,
         "pr_info_html": pr_info_html,
+        "pr_number": args.pr_number,
         "workflow_id": args.actions_run_url.split("/")[-1],
         "commit_sha": args.commit_sha,
+        "base_sha": "" if args.pr_number == 0 else pr_info.get("base", {}).get("sha"),
         "date": f"{datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')} UTC",
         "is_preview": args.mark_preview,
         "counts": {
@@ -466,6 +605,7 @@ def main():
                 if not args.known_fails
                 else len(fail_results["checks_known_fails"])
             ),
+            "pr_new_fails": len(fail_results["pr_new_fails"]),
         },
         "ci_jobs_status_html": format_results_as_html_table(
             fail_results["job_statuses"]
@@ -487,6 +627,7 @@ def main():
             if not args.known_fails
             else format_results_as_html_table(fail_results["checks_known_fails"])
         ),
+        "new_fails_html": format_results_as_html_table(fail_results["pr_new_fails"]),
     }
 
     # Render the template with the context
diff --git a/.github/workflows/grype_scan.yml b/.github/workflows/grype_scan.yml
index 1414129fd666..e749448b81ba 100644
--- a/.github/workflows/grype_scan.yml
+++ b/.github/workflows/grype_scan.yml
@@ -76,6 +76,7 @@ jobs:
           if: always()
           id: create_summary
           run: |
+            jq -r '"**Image**: \(.source.target.userInput)"' result.json >> $GITHUB_STEP_SUMMARY
             jq -r '.distro | "**Distro**: \(.name):\(.version)"' result.json >> $GITHUB_STEP_SUMMARY
             if jq -e '.matches | length == 0' result.json > /dev/null; then
               echo "No CVEs" >> $GITHUB_STEP_SUMMARY
diff --git a/.github/workflows/release_branches.yml b/.github/workflows/release_branches.yml
index e41d77464a09..9a4248a6eb20 100644
--- a/.github/workflows/release_branches.yml
+++ b/.github/workflows/release_branches.yml
@@ -59,6 +59,14 @@ jobs:
       - name: Re-create GH statuses for skipped jobs if any
         run: |
             python3 "$GITHUB_WORKSPACE/tests/ci/ci.py" --infile ${{ runner.temp }}/ci_run_data.json --update-gh-statuses
+      - name: Note report location to summary
+        env:
+          PR_NUMBER: ${{ github.event.pull_request.number || 0 }}
+          COMMIT_SHA: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+        run: |
+          REPORT_LINK=https://s3.amazonaws.com/altinity-build-artifacts/$PR_NUMBER/$COMMIT_SHA/ci_run_report.html
+          echo "Workflow Run Report: [View Report]($REPORT_LINK)" >> $GITHUB_STEP_SUMMARY
+
   BuildDockers:
     needs: [RunConfig]
     if: ${{ !failure() && !cancelled() }}
diff --git a/tests/broken_tests.json b/tests/broken_tests.json
index b45a13782f7f..e57268f72bd2 100644
--- a/tests/broken_tests.json
+++ b/tests/broken_tests.json
@@ -1,128 +1,260 @@
 {
     "02700_s3_part_INT_MAX": {
-        "reason": "Fails on asan"
+        "reason": "NEEDSFIX - Fails on asan"
     },
     "00157_cache_dictionary": {
-        "reason": "fails with asan,debug,msan"
+        "reason": "INVESTIGATE - fails with asan,debug,msan"
     },
     "02815_no_throw_in_simple_queries": {
-        "reason": "Fails on asan,msan,tsan,debug,Aarch64"
+        "reason": "INVESTIGATE - Fails on asan,msan,tsan,debug,Aarch64"
     },
     "03206_no_exceptions_clickhouse_local": {
-        "reason": "Fails on asan,msan,tsan,debug,Aarch64"
+        "reason": "INVESTIGATE - Fails on asan,msan,tsan,debug,Aarch64"
     },
     "03203_hive_style_partitioning": {
-        "reason": "new fail in 24.12"
+        "reason": "INVESTIGATE - new fail in 24.12"
+    },
+    "00988_expansion_aliases_limit": {
+        "reason": "INVESTIGATE - fails in tsan"
+    },
+    "test_overcommit_tracker/test.py::test_user_overcommit": {
+        "reason": "INVESTIGATE - fails in tsan"
+    },
+    "01037_polygon_dicts_correctness_fast": {
+        "reason": "INVESTIGATE - fails in tsan"
+    },
+    "03094_grouparraysorted_memory": {
+        "reason": "INVESTIGATE - fails in tsan"
     },
     "test_attach_partition_using_copy/test.py::test_all_replicated": {
-        "reason": "Fails on ASAN, ASAN old analyzer, Release, TSAN"
+        "reason": "NEEDSFIX - Web disk is not working"
     },
     "test_attach_partition_using_copy/test.py::test_both_mergetree": {
-        "reason": "Fails on ASAN, ASAN old analyzer, Release, TSAN"
+        "reason": "NEEDSFIX - Web disk is not working"
+    },
+    "test_attach_partition_using_copy/test.py::test_not_work_on_different_disk": {
+        "reason": "NEEDSFIX - Web disk is not working"
+    },
+    "test_attach_partition_using_copy/test.py::test_only_destination_replicated": {
+        "reason": "NEEDSFIX - Web disk is not working"
     },
     "test_backup_restore_on_cluster/test_cancel_backup.py::test_shutdown_cancels_backup": {
-        "reason": "Fails on ASAN, ASAN old analyzer, Release, TSAN"
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
     },
     "test_backup_restore_on_cluster/test_different_versions.py::test_different_versions": {
-        "reason": "Fails on ASAN, ASAN old analyzer, Release, TSAN"
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
     },
     "test_grpc_protocol/test.py::test_ipv6_select_one": {
-        "reason": "Fails on ASAN, ASAN old analyzer, Release, TSAN - FIXED in 24.8"
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN - FIXED in 24.8"
     },
     "test_settings_randomization/test.py::test_settings_randomization": {
-        "reason": "Fails on ASAN, ASAN old analyzer, Release"
-    },
-    "test_attach_partition_using_copy/test.py::test_not_work_on_different_disk": {
-        "reason": "Fails on ASAN old analyzer, TSAN"
-    },
-    "test_attach_partition_using_copy/test.py::test_only_destination_replicated": {
-        "reason": "Fails on TSAN"
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release"
     },
     "02766_prql": {
-        "reason": "KNOWN PRQL is disabled in Antalya branch"
+        "reason": "KNOWN - PRQL is disabled in Antalya branch"
     },
     "02833_local_with_dialect": {
-        "reason": "KNOWN PRQL is disabled in Antalya branch"
+        "reason": "KNOWN - PRQL is disabled in Antalya branch"
     },
     "03003_prql_panic": {
-        "reason": "KNOWN PRQL is disabled in Antalya branch"
+        "reason": "KNOWN - PRQL is disabled in Antalya branch"
     },
-    "test_git_import/test.py::/test_git_import": {
-        "reason": "NEEDSFIX 403 while getting data from GitHub"
+    "test_git_import/test.py::test_git_import": {
+        "reason": "NEEDSFIX - 403 while getting data from GitHub"
     },
     "test_storage_delta/test.py::test_types[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_types[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_single_log_file[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_single_log_file[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_restart_broken[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_restart_broken[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_restart_broken_table_function[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_restart_broken_table_function[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_replicated_database_and_unavailable_s3[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_replicated_database_and_unavailable_s3[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_partition_columns[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_partition_columns[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_partition_columns_2[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_partition_by[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_partition_by[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_multiple_log_files[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_multiple_log_files[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_metadata[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_metadata[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_filesystem_cache[1-s3]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_filesystem_cache[0-s3]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_complex_types[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_complex_types[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_checkpoint[1]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
     },
     "test_storage_delta/test.py::test_checkpoint[0]": {
-        "reason": "NEEDSFIX rust problem"
+        "reason": "NEEDSFIX - rust problem"
+    },
+    "test_cow_policy/test.py::test_cow_policy[cow_policy_multi_disk]": {
+        "reason": "NEEDSFIX - Timeout"
+    },
+    "test_cow_policy/test.py::test_cow_policy[cow_policy_multi_volume]": {
+        "reason": "NEEDSFIX - Timeout"
+    },
+    "test_s3_assume_role/test.py::test_using_assumed_creds": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_asynchronous_metric_jemalloc_profile_active/test.py::test_asynchronous_metric_jemalloc_profile_active": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_backup_restore_new/test.py::test_incremental_backup_overflow": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_mask_sensitive_info/test.py::test_create_table": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_mask_sensitive_info/test.py::test_table_functions": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_postgres_odbc_hashed_dictionary_no_tty_pipe_overflow": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_storage_iceberg/test.py::test_types[s3-1]": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_storage_iceberg/test.py::test_types[azure-2]": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_storage_iceberg/test.py::test_types[local-1]": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_storage_iceberg/test.py::test_types[local-2]": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_storage_iceberg/test.py::test_types[s3-2]": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_storage_iceberg/test.py::test_types[azure-1]": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_library_bridge/test_exiled.py::test_bridge_dies_with_parent": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_merge_tree_check_part_with_cache/test.py::test_check_part_with_cache": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_concurrent_queries": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_many_connections": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_mysql_insert": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_mysql_odbc_select_nullable": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_mysql_simple_select_works": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_no_connection_pooling": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_odbc_cyrillic_with_varchar": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_odbc_long_column_names": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_odbc_long_text": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_odbc_postgres_conversions": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_odbc_postgres_date_data_type": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_odbc_interaction/test.py::test_postgres_insert": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_async_metrics_in_cgroup/test.py::test_normalized_user_cpu": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_async_metrics_in_cgroup/test.py::test_system_wide_metrics": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_async_metrics_in_cgroup/test.py::test_user_cpu_accounting": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_jemalloc_percpu_arena/test.py::test_jemalloc_percpu_arena": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "02354_vector_search_expansion_search": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_hedged_requests_parallel/test.py::test_combination1": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_hedged_requests_parallel/test.py::test_combination2": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_hedged_requests_parallel/test.py::test_query_with_no_data_to_sample": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_hedged_requests_parallel/test.py::test_send_data": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_hedged_requests_parallel/test.py::test_send_table_status_sleep": {
+        "reason": "INVESTIGATE - Fails on ASAN, ASAN old analyzer, Release, TSAN"
+    },
+    "test_s3_cache_locality/test.py::test_cache_locality": {
+        "reason": "INVESTIGATE - Timeout on TSAN"
+    },
+    "test_reload_clusters_config/test.py::test_update_one_cluster": {
+        "reason": "INVESTIGATE - Fails on ASAN old analyzer"
     }
 }
diff --git a/tests/ci/ci_config.py b/tests/ci/ci_config.py
index dd3e3a028acb..f76f666b0641 100644
--- a/tests/ci/ci_config.py
+++ b/tests/ci/ci_config.py
@@ -373,26 +373,26 @@ class CI:
             required_builds=[BuildNames.PACKAGE_DEBUG], pr_only=True
         ),
         JobNames.INTEGRATION_TEST_ASAN: CommonJobConfigs.INTEGRATION_TEST.with_properties(
-            required_builds=[BuildNames.PACKAGE_ASAN], num_batches=4
+            required_builds=[BuildNames.PACKAGE_ASAN],
+            num_batches=8,
         ),
         JobNames.INTEGRATION_TEST_ASAN_OLD_ANALYZER: CommonJobConfigs.INTEGRATION_TEST.with_properties(
             required_builds=[BuildNames.PACKAGE_ASAN],
-            num_batches=6,
+            num_batches=8,
         ),
         JobNames.INTEGRATION_TEST_TSAN: CommonJobConfigs.INTEGRATION_TEST.with_properties(
             required_builds=[BuildNames.PACKAGE_TSAN],
-            num_batches=6,
-            timeout=9000,  # the job timed out with default value (7200)
+            num_batches=8,
         ),
         JobNames.INTEGRATION_TEST_AARCH64: CommonJobConfigs.INTEGRATION_TEST.with_properties(
             required_builds=[BuildNames.PACKAGE_AARCH64],
-            num_batches=6,
+            num_batches=8,
             runner_type=Runners.FUNC_TESTER_AARCH64,
         ),
         JobNames.INTEGRATION_TEST: CommonJobConfigs.INTEGRATION_TEST.with_properties(
             required_builds=[BuildNames.PACKAGE_RELEASE],
-            num_batches=4,
-            #release_only=True,
+            num_batches=8,
+            # release_only=True,
         ),
         JobNames.INTEGRATION_TEST_FLAKY: CommonJobConfigs.INTEGRATION_TEST.with_properties(
             required_builds=[BuildNames.PACKAGE_ASAN],
diff --git a/tests/ci/integration_tests_runner.py b/tests/ci/integration_tests_runner.py
index 17bfdb3bf5c3..54e260dc1de6 100755
--- a/tests/ci/integration_tests_runner.py
+++ b/tests/ci/integration_tests_runner.py
@@ -16,7 +16,7 @@
 import time
 from collections import OrderedDict, defaultdict
 from itertools import chain
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import yaml  # type: ignore[import-untyped]
 
@@ -27,7 +27,7 @@
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
 
-MAX_RETRY = 3
+MAX_RETRY = 2
 NUM_WORKERS = 10
 SLEEP_BETWEEN_RETRIES = 5
 PARALLEL_GROUP_SIZE = 100
@@ -116,16 +116,19 @@ def get_counters(fname: str) -> Dict[str, List[str]]:
             #
             #     test_mysql_protocol/test.py::test_golang_client
             #     [gw0] [  7%] ERROR test_mysql_protocol/test.py::test_golang_client
+            #     [gw1] SKIPPED test_odbc_interaction/test.py:56: Sanitizers cannot work with third-party shared libraries
             #
             # And only the line with test status should be matched
             if not (".py::" in line and " " in line):
                 continue
 
             line = line.strip()
-            # [gw0] [  7%] ERROR test_mysql_protocol/test.py::test_golang_client
-            # ^^^^^^^^^^^^^
+            # Remove worker info and progress percentage if present
             if line.strip().startswith("["):
-                line = re.sub(r"^\[[^\[\]]*\] \[[^\[\]]*\] ", "", line)
+                # Handle both formats:
+                # [gw0] [  7%] ERROR test_mysql_protocol/test.py::test_golang_client
+                # [gw1] SKIPPED test_odbc_interaction/test.py:56: Sanitizers cannot work with third-party shared libraries
+                line = re.sub(r"^\[[^\[\]]*\] (?:\[[^\[\]]*\] )?", "", line)
 
             line_arr = line.split(" ")
             if len(line_arr) < 2:
@@ -137,6 +140,7 @@ def get_counters(fname: str) -> Dict[str, List[str]]:
             #     ERROR test_mysql_protocol/test.py::test_golang_client
             #     PASSED test_replicated_users/test.py::test_rename_replicated[QUOTA]
             #     PASSED test_drop_is_lock_free/test.py::test_query_is_lock_free[detach part]
+            #     SKIPPED test_odbc_interaction/test.py:56: Sanitizers cannot work with third-party shared libraries
             #
             state = line_arr.pop(0)
             test_name = " ".join(line_arr)
@@ -526,6 +530,69 @@ def _update_counters(main_counters, current_counters):
             for test in current_counters[state]:
                 main_counters[state].append(test)
 
+    def _handle_broken_tests(
+        self,
+        counters: Dict[str, List[str]],
+        known_broken_tests: Dict[str, Dict[str, str]],
+        log_paths: Union[Dict[str, List[str]], List[str]],
+    ) -> None:
+
+        def get_log_paths(test_name):
+            """Could be a list of logs for all tests or a dict with test name as a key"""
+            if isinstance(log_paths, dict):
+                return log_paths[test_name]
+            return log_paths
+
+        broken_tests_log = os.path.join(self.result_path, "broken_tests_handler.log")
+
+        with open(broken_tests_log, "a") as log_file:
+            log_file.write(f"{len(known_broken_tests)} Known broken tests\n")
+            for status, tests in counters.items():
+                log_file.write(f"Total tests in {status} state: {len(tests)}\n")
+
+            for fail_status in ("ERROR", "FAILED"):
+                for failed_test in counters[fail_status].copy():
+                    log_file.write(
+                        f"Checking test {failed_test} (status: {fail_status})\n"
+                    )
+                    if failed_test not in known_broken_tests.keys():
+                        log_file.write(
+                            f"Test {failed_test} is not in known broken tests\n"
+                        )
+                    else:
+                        fail_message = known_broken_tests[failed_test].get("message")
+
+                        if not fail_message:
+                            log_file.write(
+                                "No fail message specified, marking as broken\n"
+                            )
+                            mark_as_broken = True
+                        else:
+                            log_file.write(
+                                f"Looking for fail message: {fail_message}\n"
+                            )
+                            mark_as_broken = False
+                            for log_path in get_log_paths(failed_test):
+                                if log_path.endswith(".log"):
+                                    log_file.write(f"Checking log file: {log_path}\n")
+                                    with open(log_path) as test_log:
+                                        if fail_message in test_log.read():
+                                            log_file.write(
+                                                "Found fail message in logs\n"
+                                            )
+                                            mark_as_broken = True
+                                            break
+
+                        if mark_as_broken:
+                            log_file.write(f"Moving test to BROKEN state\n")
+                            counters[fail_status].remove(failed_test)
+                            counters["BROKEN"].append(failed_test)
+                        else:
+                            log_file.write("Test not marked as broken\n")
+
+            for status, tests in counters.items():
+                log_file.write(f"Total tests in {status} state: {len(tests)}\n")
+
     def _get_runner_image_cmd(self):
         image_cmd = ""
         if self._can_run_with(
@@ -811,6 +878,7 @@ def run_flaky_check(self, build_path, should_fail=False):
         }  # type: Dict
         tests_times = defaultdict(float)  # type: Dict
         tests_log_paths = defaultdict(list)
+        known_broken_tests = self._get_broken_tests_list(self.repo_path)
         id_counter = 0
         for test_to_run in tests_to_run:
             tries_num = 1 if should_fail else FLAKY_TRIES_COUNT
@@ -827,6 +895,10 @@ def run_flaky_check(self, build_path, should_fail=False):
                     1,
                     FLAKY_REPEAT_COUNT,
                 )
+
+                # Handle broken tests on the group counters that contain test results for a single group
+                self._handle_broken_tests(group_counters, known_broken_tests, log_paths)
+
                 id_counter = id_counter + 1
                 for counter, value in group_counters.items():
                     logging.info(
@@ -989,8 +1061,6 @@ def run_normal_check(self, build_path):
             " ".join(not_found_tests[:3]),
         )
 
-        known_broken_tests = self._get_broken_tests_list(self.repo_path)
-
         grouped_tests = self.group_test_by_file(filtered_sequential_tests)
         i = 0
         for par_group in chunks(filtered_parallel_tests, PARALLEL_GROUP_SIZE):
@@ -1008,6 +1078,7 @@ def run_normal_check(self, build_path):
         tests_times = defaultdict(float)
         tests_log_paths = defaultdict(list)
         items_to_run = list(grouped_tests.items())
+        known_broken_tests = self._get_broken_tests_list(self.repo_path)
         logging.info("Total test groups %s", len(items_to_run))
         if self.shuffle_test_groups():
             logging.info("Shuffling test groups")
@@ -1021,24 +1092,8 @@ def run_normal_check(self, build_path):
                 group, tests, MAX_RETRY, NUM_WORKERS, 0
             )
 
-            for fail_status in ("ERROR", "FAILED"):
-                for failed_test in group_counters[fail_status]:
-                    if failed_test in known_broken_tests.keys():
-                        fail_message = known_broken_tests[failed_test].get("message")
-                        if not fail_message:
-                            mark_as_broken = True
-                        else:
-                            mark_as_broken = False
-                            for log_path in log_paths:
-                                if log_path.endswith(".log"):
-                                    with open(log_path) as log_file:
-                                        if fail_message in log_file.read():
-                                            mark_as_broken = True
-                                            break
-
-                        if mark_as_broken:
-                            group_counters[fail_status].remove(failed_test)
-                            group_counters["BROKEN"].append(failed_test)
+            # Handle broken tests on the group counters that contain test results for a single group
+            self._handle_broken_tests(group_counters, known_broken_tests, log_paths)
 
             total_tests = 0
             for counter, value in group_counters.items():
@@ -1062,6 +1117,7 @@ def run_normal_check(self, build_path):
             if len(counters["FAILED"]) + len(counters["ERROR"]) >= 20:
                 logging.info("Collected more than 20 failed/error tests, stopping")
                 break
+
         if counters["FAILED"] or counters["ERROR"]:
             logging.info(
                 "Overall status failure, because we have tests in FAILED or ERROR state"
diff --git a/tests/docker_scripts/stress_runner.sh b/tests/docker_scripts/stress_runner.sh
index 09d03de475d7..fbf7ca6ea74a 100755
--- a/tests/docker_scripts/stress_runner.sh
+++ b/tests/docker_scripts/stress_runner.sh
@@ -53,10 +53,17 @@ export ZOOKEEPER_FAULT_INJECTION=1
 # available for dump via clickhouse-local
 configure
 
+# NOTE(strtgbb): Our azure_storage_conf.xml is still expecting azurite
+azurite-blob --blobHost 0.0.0.0 --blobPort 10000 --debug /azurite_log &
+
 /repo/tests/docker_scripts/setup_minio.sh stateless # to have a proper environment
 
 config_logs_export_cluster /etc/clickhouse-server/config.d/system_logs_export.yaml
 
+# NOTE(strtgbb): Trying to avoid errors that may be related to running out of resources
+export CLICKHOUSE_MAX_THREADS=8
+export CLICKHOUSE_MAX_CONCURRENT_QUERIES=4
+
 start_server
 
 setup_logs_replication
diff --git a/tests/integration/test_attach_partition_using_copy/test.py b/tests/integration/test_attach_partition_using_copy/test.py
index 99fb2ff01530..206d339f333c 100644
--- a/tests/integration/test_attach_partition_using_copy/test.py
+++ b/tests/integration/test_attach_partition_using_copy/test.py
@@ -61,7 +61,9 @@ def create_source_table(node, table_name, replicated):
         SETTINGS disk = disk(type = web, endpoint = 'https://raw.githubusercontent.com/ClickHouse/web-tables-demo/main/web/')
         """.format(
             table_name=table_name, engine=engine
-        )
+        ),
+        timeout=60,
+        retry_count=3,
     )
 
 
diff --git a/tests/integration/test_cow_policy/test.py b/tests/integration/test_cow_policy/test.py
index 0d14eacbcb2b..db34c157f0ab 100644
--- a/tests/integration/test_cow_policy/test.py
+++ b/tests/integration/test_cow_policy/test.py
@@ -43,7 +43,9 @@ def test_cow_policy(start_cluster, storage_policy):
             ENGINE = MergeTree
             ORDER BY (postcode1, postcode2, addr1, addr2)
             SETTINGS storage_policy = '{storage_policy}'
-            """
+            """,
+            timeout=60,
+            retry_count=3,
         )
         prev_count = int(node.query("SELECT count() FROM uk_price_paid"))
         assert prev_count > 0
diff --git a/tests/integration/test_s3_cache_locality/test.py b/tests/integration/test_s3_cache_locality/test.py
index 088c24576d10..a2020d7e0568 100644
--- a/tests/integration/test_s3_cache_locality/test.py
+++ b/tests/integration/test_s3_cache_locality/test.py
@@ -75,7 +75,7 @@ def started_cluster():
 
 def check_s3_gets(cluster, node, expected_result, cluster_first, cluster_second, enable_filesystem_cache):
     for host in list(cluster.instances.values()):
-        host.query("SYSTEM DROP FILESYSTEM CACHE 'raw_s3_cache'")
+        host.query("SYSTEM DROP FILESYSTEM CACHE 'raw_s3_cache'", timeout=30)
 
     query_id_first = str(uuid.uuid4())
     result_first = node.query(
@@ -87,7 +87,8 @@ def check_s3_gets(cluster, node, expected_result, cluster_first, cluster_second,
           enable_filesystem_cache={enable_filesystem_cache},
           filesystem_cache_name='raw_s3_cache'
         """,
-        query_id=query_id_first
+        query_id=query_id_first,
+        timeout=30,
     )
     assert result_first == expected_result
     query_id_second = str(uuid.uuid4())
@@ -100,13 +101,14 @@ def check_s3_gets(cluster, node, expected_result, cluster_first, cluster_second,
           enable_filesystem_cache={enable_filesystem_cache},
           filesystem_cache_name='raw_s3_cache'
         """,
-        query_id=query_id_second
+        query_id=query_id_second,
+        timeout=30,
     )
     assert result_second == expected_result
 
-    node.query("SYSTEM FLUSH LOGS")
-    node.query(f"SYSTEM FLUSH LOGS ON CLUSTER {cluster_first}")
-    node.query(f"SYSTEM FLUSH LOGS ON CLUSTER {cluster_second}")
+    node.query("SYSTEM FLUSH LOGS", timeout=30)
+    node.query(f"SYSTEM FLUSH LOGS ON CLUSTER {cluster_first}", timeout=30)
+    node.query(f"SYSTEM FLUSH LOGS ON CLUSTER {cluster_second}", timeout=30)
 
     s3_get_first = node.query(
         f"""
@@ -114,7 +116,8 @@ def check_s3_gets(cluster, node, expected_result, cluster_first, cluster_second,
           FROM clusterAllReplicas('{cluster_first}', system.query_log)
           WHERE type='QueryFinish'
             AND initial_query_id='{query_id_first}'
-        """
+        """,
+        timeout=30,
     )
     s3_get_second = node.query(
         f"""
@@ -122,7 +125,8 @@ def check_s3_gets(cluster, node, expected_result, cluster_first, cluster_second,
           FROM clusterAllReplicas('{cluster_second}', system.query_log)
           WHERE type='QueryFinish'
             AND initial_query_id='{query_id_second}'
-        """
+        """,
+        timeout=30,
     )
 
     return int(s3_get_first), int(s3_get_second)