whatap-python 2.2.0__tar.gz → 2.2.1rc1__tar.gz

{whatap_python-2.2.0 → whatap_python-2.2.1rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatap-python
-Version: 2.2.0
+Version: 2.2.1rc1
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

{whatap_python-2.2.0 → whatap_python-2.2.1rc1}/whatap/__init__.py

@@ -537,9 +537,14 @@ def agent():
             llm_enabled = preview_whatap_conf("llm_enabled")
 
             if apm_enabled == 'true':
-                t = threading.Thread(target=go)
-                t.setDaemon(True)
-                t.start()
+                if sys.platform.startswith('linux'):
+                    # Publish native ownership before a short-lived interpreter
+                    # can exit. This does not wait for collector/TCP readiness.
+                    go()
+                else:
+                    t = threading.Thread(target=go)
+                    t.setDaemon(True)
+                    t.start()
 
             if llm_enabled == 'true':
                 # llm_enabled=true 라도 LLM 채널 자격증명(llm_accesskey)이 없으면 LLM
@@ -571,7 +576,60 @@ AGENT_NAME = 'whatap_python'
 
 
 
+def _native_agent_spec(opts):
+    from whatap.util.native_process import AgentSpec
+    source = os.path.join(os.path.dirname(__file__), 'agent', 'linux',
+                          ARCH[platform.machine()], AGENT_NAME)
+    env = os.environ.copy()
+    env.update(opts)
+    return AgentSpec(os.environ['WHATAP_HOME'], source, env)
+
+
+def _native_agent_log_path():
+    return os.path.join(os.environ.get('WHATAP_HOME', '.'), 'logs', AGENT_NAME + '.log')
+
+
+def _open_native_agent_log():
+    # managed 경로는 PIPE 를 읽지 않으므로 네이티브 stdout/stderr 를 파일로 남겨
+    # 기동 직후 실패 원인을 추적할 수 있게 한다.
+    try:
+        log_path = _native_agent_log_path()
+        os.makedirs(os.path.dirname(log_path), exist_ok=True)
+        return open(log_path, 'ab')
+    except Exception as e:
+        whatap_print('WHATAP: native agent log open failed: %s' % e)
+        return subprocess.DEVNULL
+
+
 def go(batch=False, opts={}, llm=False):
+    if sys.platform.startswith('linux') and not batch and not llm:
+        from whatap.util.native_process import FAILED, ensure_agent_running
+
+        def on_child_exit(pid, exit_code):
+            whatap_error_log(
+                'WHATAP: native APM exited (PID: {}, exit code: {}, log: {})'.format(
+                    pid, exit_code, _native_agent_log_path()),
+                log_id='WHATAP_AGENT_EXITED')
+
+        try:
+            spec = _native_agent_spec(opts)
+            result = ensure_agent_running(
+                spec, lambda: _start_go(batch, opts, llm, managed=True),
+                on_child_exit=on_child_exit)
+            if result.status == FAILED:
+                whatap_error_log('WHATAP: native APM startup failed',
+                                 log_id='WHATAP_AGENT_START_FAILED')
+            else:
+                whatap_print('WHATAP: native APM {} (PID: {})'.format(
+                    result.status, result.pid))
+        except Exception as e:
+            whatap_error_log('WHATAP: native APM startup failed: {}'.format(e),
+                             log_id='WHATAP_AGENT_START_FAILED')
+        return
+    return _start_go(batch, opts, llm)
+
+
+def _start_go(batch=False, opts={}, llm=False, managed=False):
     # LLM 에이전트는 Linux/macOS 를 지원한다(전용 whatap_python 이
     # $WHATAP_HOME/<os>/<arch> 에 배포됨 — linux/darwin × amd64/arm64).
     # 그 외 OS(Windows 등)는 전용 바이너리가 없으므로 우회적 "binary not found"
@@ -625,7 +683,7 @@ def go(batch=False, opts={}, llm=False):
         return ''
 
     pid = read_file(home, file_name)
-    if pid and get_pname(pid).find('whatap_python') >= 0:
+    if not managed and pid and get_pname(pid).find('whatap_python') >= 0:
         if sys.platform == 'win32':
             # Windows: Don't kill, just skip
             whatap_print('WHATAP: Agent already running (PID: {}). Skipping duplicate execution.'.format(pid))
@@ -774,6 +832,17 @@ def go(batch=False, opts={}, llm=False):
                                            cwd=home_path, env=newenv,
                                            creationflags=DETACHED_PROCESS,
                                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        elif managed:
+            go_out = _open_native_agent_log()
+            try:
+                process = subprocess.Popen(cmd_args,
+                                           cwd=home_path, env=newenv,
+                                           start_new_session=True,
+                                           stdout=go_out, stderr=go_out)
+            finally:
+                if go_out is not subprocess.DEVNULL:
+                    go_out.close()
+            return process
         else:
             process = subprocess.Popen(cmd_args,
                                        cwd=home_path, env=newenv,
@@ -1086,6 +1155,22 @@ def get_port_number(port=6600, home=os.environ.get('WHATAP_HOME'), lock_file=Non
 
 
 def configPort():
+    if sys.platform.startswith('linux') and preview_whatap_conf('apm_enabled') == 'true':
+        from whatap.util.native_process import acquire_start_lock, configured_channel, find_existing_agent
+        try:
+            spec = _native_agent_spec({})
+            with acquire_start_lock(spec):
+                if find_existing_agent(spec):
+                    # CLI allocation must not rewrite a live bootstrap agent's channel.
+                    return configured_channel(spec.home, spec.environment, include_unix=False)[1]
+                return _config_port()
+        except Exception as e:
+            # 락 타임아웃/다중 인스턴스 등은 CLI 를 죽이지 말고 기존 포트 할당으로 폴백
+            whatap_print('WHATAP: live agent check skipped, falling back to port file: %s' % e)
+    return _config_port()
+
+
+def _config_port():
     # force_net_udp_port가 설정된 경우 lock 파일 무시하고 해당 포트 강제 사용
     force_port_str = preview_whatap_conf("force_net_udp_port")
     if force_port_str and force_port_str not in ('false', 'False'):

whatap_python-2.2.1rc1/whatap/build.py

@@ -0,0 +1,4 @@
+app = 'Python'
+name = 'whatap-python'
+version = '2.2.1rc1'
+release_date = '20260916'

whatap_python-2.2.1rc1/whatap/util/native_process.py

@@ -0,0 +1,458 @@
+"""Linux APM native process ownership (not instrumentation configuration)."""
+import os
+import errno
+import fcntl
+import filecmp
+import json
+import re
+import stat
+import subprocess
+import tempfile
+import threading
+import time
+from collections import namedtuple
+from contextlib import contextmanager
+from pathlib import Path
+
+STARTED = 'started'
+REUSED = 'reused'
+FAILED = 'failed'
+IN_PROGRESS = 'in_progress'
+StartResult = namedtuple('StartResult', 'status pid')
+DISCOVERY_TIMEOUT_SECONDS = 1.0
+LOCK_TIMEOUT_SECONDS = 1.0
+LOCK_RETRY_SECONDS = 0.01
+DEFAULT_UDP_PORT = 6600
+CONFIG_MAX_BYTES = 1024 * 1024
+RECORD_MAX_BYTES = 8192
+CHILD_STOP_TIMEOUT_SECONDS = 2.0
+STARTUP_GRACE_SECONDS = 0.5
+STARTUP_POLL_SECONDS = 0.05
+_TRUE_VALUES = ('1', 't', 'T', 'true', 'TRUE', 'True')
+_watchers = set()
+_watchers_lock = threading.Lock()
+_start_lock_fds = set()
+_start_lock_fds_lock = threading.Lock()
+
+
+def _before_fork():
+    # Serialize only descriptor bookkeeping, never flock acquisition or yield.
+    _start_lock_fds_lock.acquire()
+
+
+def _after_fork_parent():
+    _start_lock_fds_lock.release()
+
+
+def _after_fork():
+    global _watchers, _watchers_lock, _start_lock_fds, _start_lock_fds_lock
+    for fd in _start_lock_fds:
+        # LOCK_UN would also unlock the parent's shared open-file description.
+        try:
+            os.close(fd)
+        except OSError:
+            pass
+    _start_lock_fds = set()
+    _start_lock_fds_lock = threading.Lock()
+    _watchers = set()
+    _watchers_lock = threading.Lock()
+
+
+os.register_at_fork(before=_before_fork, after_in_parent=_after_fork_parent,
+                    after_in_child=_after_fork)
+
+
+def watch_owned_child(pid, process=None, on_exit=None):
+    if process is None:
+        try:
+            fields = (Path('/proc') / str(pid) / 'stat').read_text().rsplit(')', 1)[1].split()
+            if int(fields[1]) != os.getpid():
+                return
+        except (FileNotFoundError, ProcessLookupError):
+            return
+    key = (os.getpid(), pid)
+    with _watchers_lock:
+        if key in _watchers:
+            return
+        _watchers.add(key)
+
+    def wait():
+        try:
+            if process is not None:
+                process.wait()
+            else:
+                os.waitpid(pid, 0)
+        except ChildProcessError:
+            # An application may also reap its children. Never wait for -1 or
+            # replace SIGCHLD: those are application-owned contracts.
+            pass
+        finally:
+            if on_exit is not None:
+                try:
+                    on_exit()
+                except (OSError, RuntimeError):
+                    # A stale record is safe: it is revalidated on every start.
+                    pass
+            with _watchers_lock:
+                _watchers.discard(key)
+
+    thread = threading.Thread(target=wait, name='whatap-native-wait-{}'.format(pid))
+    thread.daemon = True
+    try:
+        thread.start()
+    except Exception:
+        with _watchers_lock:
+            _watchers.discard(key)
+        raise
+
+
+def configured_channel(home, env, include_unix=True):
+    """Read only native transport keys, including native file/ENV precedence.
+
+    whatap.port is an object identity input, NOT the UDP listener port.
+    """
+    aliases = {'net_udp_port': 'WHATAP_NET_UDP_PORT',
+               'use_env_first': 'WHATAP_USE_ENV_FIRST'}
+    keys = ('net_udp_port', 'use_env_first', 'unix_socket_enabled', 'unix_socket')
+    config_home = env.get('WHATAP_CONFIG_HOME') or home
+    config_name = env.get('WHATAP_CONFIG') or 'whatap.conf'
+    # Preserve Go path.Join semantics before resolving against native cwd.
+    config_path = os.path.normpath(config_home + '/' + config_name)
+    if not os.path.isabs(config_path):
+        config_path = os.path.join(home, config_path)
+    values = {}
+    try:
+        with open(config_path) as stream:
+            content = stream.read(CONFIG_MAX_BYTES + 1)
+        if len(content) > CONFIG_MAX_BYTES:
+            raise RuntimeError('native configuration exceeds startup read limit')
+        for line in content.splitlines():
+            line = line.strip()
+            if not line or line.startswith(('#', '!')):
+                continue
+            key, separator, value = line.partition('=')
+            if separator and key.strip() in keys:
+                values[key.strip()] = value.strip()
+    except FileNotFoundError:
+        pass
+
+    def env_value(key):
+        return (env.get(key) or env.get(aliases.get(key, ''), '')).strip()
+
+    # The native loader resets UseEnvFirst before reading UseEnvFirst itself.
+    env_first = values.get('use_env_first', env_value('use_env_first')) in _TRUE_VALUES
+
+    def get(key, default):
+        value = env_value(key)
+        if not (env_first and value):
+            value = values.get(key, value)
+        return value or default
+
+    if include_unix and get('unix_socket_enabled', 'false') in _TRUE_VALUES:
+        # Go path.Join joins even a leading slash in its second argument.
+        path = os.path.normpath(home + '/' + get('unix_socket', 'whatap.sock'))
+        return ('unix', path)
+    try:
+        value = get('net_udp_port', str(DEFAULT_UDP_PORT))
+        # Native strconv.ParseInt(value, 10, 32) rejects Python-only syntax.
+        if re.fullmatch(r'[+-]?[0-9]+', value) is None:
+            raise ValueError('invalid native decimal')
+        port = int(value)
+        if not -2147483648 <= port <= 2147483647:
+            raise ValueError('native decimal exceeds int32')
+    except ValueError:
+        port = DEFAULT_UDP_PORT
+    if not 0 <= port <= 65535:
+        raise ValueError('native APM UDP port is out of range')
+    return ('udp', port)
+
+
+def channel_socket_inodes(channel):
+    kind, address = channel
+    inodes = set()
+    tables = ('unix',) if kind == 'unix' else ('udp', 'udp6')
+    for table in tables:
+        try:
+            lines = (Path('/proc/net') / table).read_text().splitlines()[1:]
+        except FileNotFoundError:
+            if table == 'udp6':
+                continue
+            raise
+        for line in lines:
+            fields = line.split(None, 7) if kind == 'unix' else line.split()
+            if kind == 'unix':
+                if len(fields) == 8 and fields[7] == address:
+                    inodes.add(fields[6])
+            elif address and int(fields[1].rsplit(':', 1)[1], 16) == address:
+                inodes.add(fields[9])
+    return inodes
+
+
+def owns_socket(pid, inodes):
+    sockets = {'socket:[{}]'.format(inode) for inode in inodes}
+    if not sockets:
+        return False
+    try:
+        with os.scandir('/proc/{}/fd'.format(pid)) as descriptors:
+            for descriptor in descriptors:
+                try:
+                    sockets.discard(os.readlink(descriptor.path))
+                    if not sockets:
+                        return True
+                except FileNotFoundError:
+                    continue
+    except FileNotFoundError:
+        return False
+    return False
+
+
+class AgentSpec(object):
+    def __init__(self, home, executable, env=None):
+        self.home = os.path.realpath(home)
+        self.executable = os.path.realpath(executable)
+        environment = os.environ if env is None else env
+        # Retain only transport/config-location keys, never credentials.
+        self.environment = {key: environment[key] for key in (
+            'net_udp_port', 'WHATAP_NET_UDP_PORT', 'use_env_first',
+            'WHATAP_USE_ENV_FIRST', 'unix_socket_enabled', 'unix_socket',
+            'WHATAP_CONFIG_HOME', 'WHATAP_CONFIG') if key in environment}
+        self.channel = None  # Read under the startup lock, not before waiting.
+        self.pid_file = Path(self.home) / 'whatap_python.pid'
+        namespaces = '{}-{}'.format(os.stat('/proc/self/ns/pid').st_ino,
+                                   os.stat('/proc/self/ns/net').st_ino)
+        self.namespaces = namespaces
+        self.lock_file = Path(self.home) / ('whatap_python.' + namespaces + '.lock')
+        self.record_file = Path(self.home) / ('whatap_python.' + namespaces + '.runtime.json')
+
+
+def _process_stat(pid):
+    # comm can contain spaces/parentheses. After its final ')', state is field 3
+    # and the process start time is field 22.
+    fields = (Path('/proc') / str(pid) / 'stat').read_text().rsplit(')', 1)[1].split()
+    return {'pid': pid, 'state': fields[0], 'ppid': int(fields[1]), 'start_time': fields[19]}
+
+
+def _read_record(spec):
+    try:
+        with spec.record_file.open() as stream:
+            content = stream.read(RECORD_MAX_BYTES + 1)
+        if len(content) > RECORD_MAX_BYTES:
+            raise RuntimeError('native APM ownership record is too large')
+        value = json.loads(content)
+        return value if isinstance(value, dict) else {}
+    except (FileNotFoundError, ValueError):
+        return {}
+
+
+def _atomic_write(path, content):
+    fd, temporary = tempfile.mkstemp(prefix=path.name + '.', dir=str(path.parent))
+    try:
+        with os.fdopen(fd, 'w') as stream:
+            stream.write(content)
+        os.replace(temporary, str(path))
+    finally:
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass
+
+
+def write_runtime_record(spec, pid):
+    info = _process_stat(pid)
+    if info['state'] in ('Z', 'X'):
+        raise RuntimeError('native APM exited during startup')
+    record = {'pid': pid, 'start_time': info['start_time'],
+              'channel': list(spec.channel), 'namespaces': spec.namespaces}
+    if _read_record(spec) != record:
+        _atomic_write(spec.record_file, json.dumps(record))
+    try:
+        unchanged = spec.pid_file.read_text().strip() == str(pid)
+    except FileNotFoundError:
+        unchanged = False
+    if not unchanged:
+        _atomic_write(spec.pid_file, str(pid))
+    return record
+
+
+def _clear_record(spec, record):
+    with acquire_start_lock(spec):
+        if _read_record(spec) == record:
+            spec.record_file.unlink()
+
+
+@contextmanager
+def acquire_start_lock(spec):
+    flags = os.O_RDWR | os.O_CREAT | os.O_CLOEXEC | os.O_NOFOLLOW
+    owner_pid = os.getpid()
+    with _start_lock_fds_lock:
+        fd = os.open(str(spec.lock_file), flags, 0o600)
+        _start_lock_fds.add(fd)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode) or info.st_nlink != 1:
+            raise RuntimeError('unsafe native APM lock file')
+        deadline = time.monotonic() + LOCK_TIMEOUT_SECONDS
+        while True:
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                break
+            except OSError as error:
+                if error.errno not in (errno.EAGAIN, errno.EACCES):
+                    raise
+                if time.monotonic() >= deadline:
+                    raise TimeoutError('native APM startup lock is busy')
+                time.sleep(LOCK_RETRY_SECONDS)
+        yield
+    finally:
+        # Closing releases the lock. Never unlink: another waiter may have opened
+        # this inode already, and a replacement inode would allow two owners.
+        if os.getpid() == owner_pid:
+            with _start_lock_fds_lock:
+                try:
+                    os.close(fd)
+                finally:
+                    _start_lock_fds.discard(fd)
+
+
+def _matching_process(pid, spec, record):
+    """A name/PID alone is not an identity; do not adopt other applications."""
+    root = Path('/proc') / str(pid)
+    try:
+        info = _process_stat(pid)
+        if info['state'] in ('Z', 'X'):
+            return False
+        if os.path.realpath(os.readlink(str(root / 'cwd'))) != spec.home:
+            return False
+        args = (root / 'cmdline').read_bytes().split(b'\0')
+        if b'--llm' in args:
+            return False
+        namespaces = '{}-{}'.format(os.stat(str(root / 'ns/pid')).st_ino,
+                                   os.stat(str(root / 'ns/net')).st_ino)
+        if namespaces != spec.namespaces:
+            return False
+        process_exe = str(root / 'exe')
+        same_binary = os.path.samefile(process_exe, spec.executable)
+        if not same_binary and os.path.realpath(os.readlink(process_exe)) == os.path.join(spec.home, 'whatap_python'):
+            # _start_go copies when the filesystem does not support symlinks.
+            # Path/name alone is insufficient: compare the actual executable.
+            same_binary = filecmp.cmp(process_exe, spec.executable, shallow=False)
+        if not same_binary:
+            if (root / 'comm').read_text().strip() == 'whatap_python':
+                raise RuntimeError('different native APM executable is already running in this home')
+            return False
+        if record.get('pid') == pid and record.get('start_time') == info['start_time']:
+            if record.get('channel') != list(spec.channel):
+                raise RuntimeError('running native APM channel differs from current configuration')
+        return True
+    except (FileNotFoundError, ProcessLookupError):
+        return False
+
+
+def find_existing_agent(spec):
+    """Caller holds acquire_start_lock, including during port-file allocation."""
+    spec.channel = configured_channel(spec.home, spec.environment)
+    record = _read_record(spec)
+    recorded_pid = record.get('pid')
+    if isinstance(recorded_pid, int) and recorded_pid > 0:
+        if _matching_process(recorded_pid, spec, record):
+            return recorded_pid
+    try:
+        pid = int(spec.pid_file.read_text().strip())
+    except (FileNotFoundError, ValueError):
+        pid = None
+    if pid and pid > 0 and _matching_process(pid, spec, record):
+        return pid
+    matches = []
+    deadline = time.monotonic() + DISCOVERY_TIMEOUT_SECONDS
+    with os.scandir('/proc') as entries:
+        for entry in entries:
+            if time.monotonic() > deadline:
+                raise RuntimeError('native APM process discovery timed out')
+            if not entry.name.isdigit():
+                continue
+            try:
+                comm = (Path(entry.path) / 'comm').read_text().strip()
+                if comm != 'whatap_python':
+                    continue
+                candidate = int(entry.name)
+                if _matching_process(candidate, spec, record):
+                    matches.append(candidate)
+            except (FileNotFoundError, ProcessLookupError):
+                continue
+    if len(matches) > 1:
+        raise RuntimeError('multiple native APM instances already exist')
+    return matches[0] if matches else None
+
+
+def ensure_agent_running(spec, spawn, on_child_exit=None):
+    try:
+        with acquire_start_lock(spec):
+            return _ensure_locked(spec, spawn, on_child_exit)
+    except TimeoutError:
+        return StartResult(IN_PROGRESS, None)
+
+
+def _early_exit_code(process):
+    """Return the exit code if the child dies within the startup grace period."""
+    deadline = time.monotonic() + STARTUP_GRACE_SECONDS
+    while True:
+        code = process.poll()
+        if isinstance(code, int):
+            return code
+        if time.monotonic() >= deadline:
+            return None
+        time.sleep(STARTUP_POLL_SECONDS)
+
+
+def _owned_child_exited(spec, record, process, on_child_exit):
+    try:
+        _clear_record(spec, record)
+    finally:
+        if on_child_exit is not None:
+            try:
+                on_child_exit(process.pid, process.returncode)
+            except Exception:
+                pass
+
+
+def _ensure_locked(spec, spawn, on_child_exit=None):
+    pid = find_existing_agent(spec)
+    occupied = channel_socket_inodes(spec.channel)
+    if occupied and (not pid or not owns_socket(pid, occupied)):
+        raise RuntimeError('native APM channel is occupied by another process')
+    if pid:
+        previous = _read_record(spec)
+        known = (previous.get('pid') == pid and
+                 previous.get('start_time') == _process_stat(pid)['start_time'] and
+                 previous.get('channel') == list(spec.channel) and
+                 previous.get('namespaces') == spec.namespaces)
+        if not known and not occupied:
+            # Legacy native may still be connecting, or use a different channel.
+            # Neither duplicate it nor silently certify its current config.
+            watch_owned_child(pid)
+            return StartResult(IN_PROGRESS, pid)
+        record = write_runtime_record(spec, pid)
+        watch_owned_child(pid, on_exit=lambda: _clear_record(spec, record))
+        return StartResult(REUSED, pid)
+    process = spawn()
+    if process is None:
+        return StartResult(FAILED, None)
+    exit_code = _early_exit_code(process)
+    if exit_code is not None:
+        raise RuntimeError('native APM exited immediately (PID {}, exit code {})'.format(
+            process.pid, exit_code))
+    try:
+        record = write_runtime_record(spec, process.pid)
+        watch_owned_child(process.pid, process,
+                          on_exit=lambda: _owned_child_exited(spec, record, process, on_child_exit))
+    except Exception:
+        # Only this Popen's child is ours to stop. Never abandon a child after a
+        # metadata/thread failure, and never kill a process found by discovery.
+        process.terminate()
+        try:
+            process.wait(timeout=CHILD_STOP_TIMEOUT_SECONDS)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait(timeout=CHILD_STOP_TIMEOUT_SECONDS)
+        raise
+    return StartResult(STARTED, process.pid)

{whatap_python-2.2.0 → whatap_python-2.2.1rc1}/whatap_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatap-python
-Version: 2.2.0
+Version: 2.2.1rc1
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

{whatap_python-2.2.0 → whatap_python-2.2.1rc1}/whatap_python.egg-info/SOURCES.txt

@@ -223,6 +223,7 @@ whatap/util/keygen.py
 whatap/util/linked_list.py
 whatap/util/linked_map.py
 whatap/util/metering_util.py
+whatap/util/native_process.py
 whatap/util/request_double_queue.py
 whatap/util/request_queue.py
 whatap/util/string_util.py

whatap_python-2.2.0/whatap/build.py

@@ -1,4 +0,0 @@
-app = 'Python'
-name = 'whatap-python'
-version = '2.2.0'
-release_date = '20260901'