solnlib 8.2.0b1__tar.gz → 8.2.1b1__tar.gz

{solnlib-8.2.0b1 → solnlib-8.2.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solnlib
-Version: 8.2.0b1
+Version: 8.2.1b1
 Summary: The Splunk Software Development Kit for Splunk Solutions
 License: Apache-2.0
 License-File: LICENSE

{solnlib-8.2.0b1 → solnlib-8.2.1b1}/pyproject.toml

@@ -16,7 +16,7 @@
 
 [tool.poetry]
 name = "solnlib"
-version = "8.2.0-beta.1"
+version = "8.2.1-beta.1"
 description = "The Splunk Software Development Kit for Splunk Solutions"
 authors = ["Splunk <addonfactory@splunk.com>"]
 license = "Apache-2.0"

{solnlib-8.2.0b1 → solnlib-8.2.1b1}/solnlib/__init__.py

@@ -55,4 +55,4 @@ __all__ = [
     "utils",
 ]
 
-__version__ = "8.2.0-beta.1"
+__version__ = "8.2.1-beta.1"

{solnlib-8.2.0b1 → solnlib-8.2.1b1}/solnlib/observability.py

@@ -53,7 +53,7 @@ import threading
 import urllib.request
 from typing import Callable, ClassVar, Optional, Union
 from ._observability_flush import _register_controller
-from .splunkenv import get_conf_stanzas
+from .splunkenv import _get_running_app_name, get_conf_stanzas
 from opentelemetry.metrics import Instrument, Meter
 from opentelemetry.sdk.metrics import MeterProvider, Counter, Histogram
 from opentelemetry.sdk.metrics.export import (
@@ -392,12 +392,14 @@ class ObservabilityService:
             logger: Python logger (or ``LoggerAdapter``) for all diagnostic
                 output.  Typically the caller's own module-level logger.
             ta_name: Add-on identifier, e.g. ``"Splunk_TA_myapp"``.  When
-                *None* the value is read from the ``[id]`` stanza of
-                ``app.conf`` via :func:`~solnlib.splunkenv.get_conf_stanzas`.
-                Pass it explicitly when the add-on runs outside a full Splunk
-                environment or to avoid the ``app.conf`` lookup.
+                *None* the value is read from the ``[id]`` stanza of the
+                ``app.conf`` of the running app (detected from the main
+                script's path, then solnlib's own path; falling back to the
+                app directory name).
+                Pass it explicitly when the add-on runs outside a standard
+                ``etc/apps/<app>`` layout or to avoid the ``app.conf`` lookup.
             ta_version: Add-on version string, e.g. ``"3.1.0"``.  When *None*
-                the value is read from the ``[launcher]`` stanza of
+                the value is read from the ``[launcher]`` stanza of the same
                 ``app.conf``.  Falls back to ``"unknown"`` if it cannot be
                 determined.
             extra_exporters: Optional list of additional
@@ -433,8 +435,8 @@ class ObservabilityService:
 
             if not ta_name:
                 raise ValueError(
-                    "ta_name could not be determined: pass it explicitly or ensure "
-                    "app.conf is readable via btool"
+                    "ta_name could not be determined: pass it explicitly or run "
+                    "the add-on from etc/apps/<app>"
                 )
 
             resource = Resource(
@@ -504,19 +506,29 @@ class ObservabilityService:
         )
 
     def _read_ta_info(self) -> tuple[Optional[str], Optional[str]]:
-        """Read the add-on name and version from ``app.conf``.
+        """Read the add-on name and version from the owning app's ``app.conf``.
 
-        Returns a ``(ta_name, ta_version)`` tuple.  Either value is
-        ``None`` when the corresponding key is missing or when
-        ``app.conf`` cannot be read (e.g. outside a Splunk environment).
+        The owning app is the one whose script is running
+        (``etc/apps/<app>/bin/...``), or failing that the one that bundles
+        solnlib.  The lookup is always scoped to that app: an unscoped
+        ``app.conf`` merge can return another installed add-on's ``[id]``
+        stanza.
+
+        Returns a ``(ta_name, ta_version)`` tuple.  Both are ``None`` when the
+        owning app cannot be detected or ``app.conf`` cannot be read; the
+        version alone is ``None`` when ``[launcher] version`` is missing.
         """
         try:
-            stanzas = get_conf_stanzas("app")
-            ta_name = stanzas.get("id", {}).get("name") or None
-            scoped_stanzas = (
-                get_conf_stanzas("app", app_name=ta_name) if ta_name else stanzas
-            )
-            ta_version = scoped_stanzas.get("launcher", {}).get("version") or None
+            app_name = _get_running_app_name()
+            if not app_name:
+                self._logger.info(
+                    "Could not determine the running add-on from the script "
+                    "or solnlib path; app.conf not read"
+                )
+                return None, None
+            stanzas = get_conf_stanzas("app", app_name=app_name)
+            ta_name = stanzas.get("id", {}).get("name") or app_name
+            ta_version = stanzas.get("launcher", {}).get("version") or None
             return ta_name, ta_version
         except Exception as error:
             self._logger.info(

{solnlib-8.2.0b1 → solnlib-8.2.1b1}/solnlib/splunkenv.py

@@ -19,9 +19,11 @@ import os
 import os.path as op
 import socket
 import subprocess
+import sys
 import json
 from configparser import ConfigParser
 from io import StringIO
+from pathlib import Path
 from typing import Optional, Union
 import __main__
 from solnlib._settings import use_btool
@@ -66,6 +68,7 @@ __all__ = [
 ETC_LEAF = "etc"
 APP_SYSTEM = "system"
 APP_HEC = "splunk_httpinput"
+_APPS_DIRS = ("apps", "peer-apps", "slave-apps")
 
 
 class SessionKeyNotFound(Exception):
@@ -92,6 +95,65 @@ def make_splunkhome_path(parts: Union[list, tuple]) -> str:
     return msp(parts)
 
 
+def _is_splunk_etc_dir(path: Path) -> bool:
+    if op.normcase(path.name) == ETC_LEAF:
+        return True
+    splunk_etc = os.environ.get("SPLUNK_ETC")
+    return bool(splunk_etc) and op.normcase(op.realpath(splunk_etc)) == op.normcase(
+        op.realpath(path)
+    )
+
+
+def _get_app_name_from_path(path: str) -> Optional[str]:
+    """Return the name of the Splunk app that contains `path`.
+
+    The app is the directory directly under ``$SPLUNK_ETC/apps`` (or
+    ``peer-apps`` / ``slave-apps`` on indexer cluster peers). For example,
+    ``$SPLUNK_HOME/etc/apps/Splunk_TA_test/bin/input.py`` resolves to
+    ``"Splunk_TA_test"``.
+
+    Arguments:
+        path: File system path to inspect.
+
+    Returns:
+        App name, or None if `path` is not inside a Splunk apps directory.
+    """
+    # Not utils.get_appname_from_path: that one returns "-", ignores
+    # SPLUNK_ETC and slave-apps, and is public, so its behaviour is kept.
+    try:
+        # abspath, not resolve(): apps symlinked into etc/apps keep their name.
+        absolute = Path(op.abspath(path))
+        # Outermost match first: Splunk's etc/apps sits above anything an app
+        # vendors that happens to contain etc/apps.
+        for candidate in reversed((absolute, *absolute.parents)):
+            parent = candidate.parent
+            if op.normcase(parent.name) in _APPS_DIRS and _is_splunk_etc_dir(
+                parent.parent
+            ):
+                return candidate.name
+    except (OSError, ValueError):
+        pass
+    return None
+
+
+def _get_running_app_name() -> Optional[str]:
+    """Return the name of the Splunk app whose script is running.
+
+    Tries the main script first (modular inputs, alert actions and search
+    commands run from ``etc/apps/<app>/bin``; this path also keeps
+    symlinked app directories intact), then falls back to the app that
+    bundles solnlib.
+
+    Returns:
+        App name, or None if neither path is inside a Splunk apps directory.
+    """
+    argv = getattr(sys, "argv", None)
+    main_path = getattr(__main__, "__file__", None) or (argv[0] if argv else None)
+    return (main_path and _get_app_name_from_path(main_path)) or (
+        _get_app_name_from_path(__file__)
+    )
+
+
 def get_splunk_host_info(session_key: Optional[str] = None) -> tuple:
     """Get splunk host info.