```python
import logging
import requests
import os
import pandas as pd
from deltalake import write_deltalake
from datetime import datetime
import azure.functions as func
from concurrent.futures import ThreadPoolExecutor, as_completed

### Initialize Azure Function app ###
app = func.FunctionApp()

### Define configuration variables and API URLs ###
AZURE_STORAGE_ACCOUNT_NAME = os.getenv("AZURE_STORAGE_ACCOUNT_NAME")
AZURE_STORAGE_ACCOUNT_KEY = os.getenv("AZURE_STORAGE_ACCOUNT_KEY")
CONTAINER_NAME = "data" # Rename this to your ADLS file system name

API_URLS = {
    "astro": "http://www.7timer.info/bin/api.pl?lon=113.17&lat=23.09&product=astro&output=json",
    "civil": "http://www.7timer.info/bin/api.pl?lon=113.17&lat=23.09&product=civil&output=json",
    "civillight": "http://www.7timer.info/bin/api.pl?lon=113.17&lat=23.09&product=civillight&output=json",
    "meteo": "http://www.7timer.info/bin/api.pl?lon=113.17&lat=23.09&product=meteo&output=json",
    "two": "http://www.7timer.info/bin/api.pl?lon=113.17&lat=23.09&product=two&output=json",
}

### Define functions to fetch, transform, and store the data ###
def fetch_api_data(api_url):
    """Fetch JSON data from the given API URL."""
    try:
        response = requests.get(api_url)
        response.raise_for_status()
        data = response.json()

        if not data or "dataseries" not in data:
            logging.warning(f"⚠️ API {api_url} returned empty or invalid response.")
            return None

        return data
    except requests.exceptions.RequestException as e:
        logging.error(f"❌ Failed to fetch data from API: {api_url} | Error: {e}")
        return None


def transform_api_data(api_name, data):
    """Transform JSON response into a pandas DataFrame."""
    try:
        df = pd.json_normalize(data, record_path=["dataseries"], meta=["product", "init"])
        df["ingestion_timestamp_utc"] = datetime.utcnow()

        if df.empty:
            logging.warning(f"⚠️ No records found in {api_name}, skipping storage.")
            return None

        return df
    except Exception as e:
        logging.error(f"❌ Failed to process data for {api_name}: {e}")
        return None


def store_data_in_adls(api_name, df):
    """Write the DataFrame to Delta format in ADLS."""
    if df is None or df.empty:
        logging.warning(f"⚠️ No data to store for {api_name}. Skipping write.")
        return

    adls_path = f"abfss://{CONTAINER_NAME}@{AZURE_STORAGE_ACCOUNT_NAME}.dfs.core.windows.net/{api_name}"

    storage_options = {
        "AZURE_STORAGE_ACCOUNT_NAME": AZURE_STORAGE_ACCOUNT_NAME,
        "AZURE_STORAGE_ACCOUNT_KEY": AZURE_STORAGE_ACCOUNT_KEY,
    }

    try:
        logging.info(f"📤 Writing data for {api_name} to {adls_path} (overwrite mode)...")

        write_deltalake(
            adls_path,
            df,
            mode="overwrite",
            schema_mode="merge",
            storage_options=storage_options,
        )
        logging.info(f"✅ Successfully written {api_name} data to ADLS.")
    except Exception as e:
        logging.error(f"❌ Failed to store data for {api_name}: {e}")


def fetch_and_store_data(api_name, api_url):
    """Fetch, transform, and store data for a given API."""
    logging.info(f"🔄 Starting processing for {api_name}...")

    data = fetch_api_data(api_url)
    if data:
        df = transform_api_data(api_name, data)
        store_data_in_adls(api_name, df)

    logging.info(f"✅ Finished processing {api_name}.")

### Define the timer trigger decorator & orchestrator function to run every 10th minute ###
@app.timer_trigger(
    schedule="0 */10 * * * *",
    arg_name="appTimer",
    run_on_startup=False,
    use_monitor=False,
)
def app_trigger_process_api_data(appTimer: func.TimerRequest) -> None:
    """Orchestrator function to fetch, process, and store data."""
    logging.info("🔄 Python timer trigger function started.")

    if appTimer.past_due:
        logging.warning("⚠️ The timer is past due!")

    try:
        with ThreadPoolExecutor() as executor:
            futures = {
                executor.submit(fetch_and_store_data, name, url): name for name, url in API_URLS.items()
            }

            # Logging when threads complete
            for future in as_completed(futures):
                try:
                    future.result()  # Ensures exceptions are raised
                    logging.info(f"✅ Completed processing for {futures[future]}")
                except Exception as e:
                    logging.error(f"❌ {futures[future]} failed with error: {e}")

    except Exception as e:
        logging.error(f"❌ An error occurred in multi-threading: {e}")

    logging.info("✅ Python timer trigger function completed.")

```

---