ivcap-lambda 0.7.22__py3-none-any.whl

ivcap_lambda/__init__.py

@@ -0,0 +1,17 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+"""A library supporting the development of tools for agents to be deployed on  IVCAP"""
+
+from .version import __version__
+
+from .server import start_tool_server
+from .builder import add_tool_api_route, ToolOptions
+from .executor import ExecutionContext, get_event_reporter, get_job_id
+from .utils import get_public_url_prefix
+from .secret import SecretMgrClient
+from .decorators import ivcap_lambda
+from .decorators import ivcap_lambda as ivcap_ai_tool  # backward-compat alias
+from .logger import logging_init

ivcap_lambda/builder.py

@@ -0,0 +1,260 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import asyncio
+from dataclasses import dataclass
+import json
+from fastapi import FastAPI, Response, status, Request
+from pydantic import BaseModel, Field
+from typing import Any, Dict, List, Optional, Callable, Tuple, Type, TypeVar
+from uuid6 import uuid6
+
+from ivcap_service import getLogger, get_function_return_type, get_input_type, create_tool_definition
+from ivcap_service import IvcapResult, ToolDefinition, ExecutionError
+
+from .executor import ExecutionContext, Executor, ExecutorOpts
+from .utils import get_title_from_path, get_public_url_prefix
+
+
+class ErrorModel(BaseModel):
+    message: str
+    code: int
+
+class ExecutionErrorModel(BaseModel):
+    jschema: str = Field("urn:ivcap:schema.ai-tool.error.1", alias="$schema")
+    message: str
+    traceback: str
+
+JOB_URN_PREFIX = "urn:ivcap:job:"
+
+logger = getLogger("wrapper")
+
+class ToolOptions(BaseModel):
+    name: Optional[str] = Field(None, description="Name to be used for this tool")
+    tags: Optional[list[str]] = Field(None, description="OpenAPI tag for this set of functions")
+    max_wait_time: Optional[float] = Field(5.0, description="max. time in seconds to wait for result and before returning RetryLater")
+    refresh_interval: Optional[int] = Field(3, description="Time in seconds to wait before chacking again for a job result (used in RetryLater)")
+    executor_opts: Optional[ExecutorOpts] = Field(None, description="Options for the executor")
+    post_route_opts: Optional[Dict[str, Any]] = Field({}, description="Addtitional options given the POST route constructor")
+    service_id: Optional[str] = Field(None, description="overriding the default service id")
+
+# Define a generic type for Pydantic models
+T = TypeVar("T", bound=BaseModel)
+
+WorkerFn = Callable[[BaseModel, Optional[ExecutionContext], Optional[Response]], BaseModel]
+
+@dataclass
+class ToolDescription:
+    name: str
+    path_prefix: str
+    worker_fn: WorkerFn
+    input: Tuple[Optional[Type[BaseModel]], Dict[str, Any]]
+    executor: Executor
+
+tools: List[ToolDescription] = []
+
+def add_tool_api_route(
+    app: FastAPI,
+    path_prefix: str,
+    worker_fn: WorkerFn,
+    *,
+    opts: Optional[ToolOptions] = ToolOptions(),
+    context: Optional[ExecutionContext] = None
+):
+    """Add a few routes to `app` for use with an AI tool.
+
+    The tool itself is implemented in `worker_fn` where the first
+    argument is a pydantic model describing all the tool's "public" parameters.
+    The function is also expected to return it's result as a single pydantic model.
+    The tool function can have two optioanl paramters, one with the same type as
+    `context` and the second one with `fastapi.Request`. The context paramter will
+    be identical to the above `context`, while the `request` will be the incoming
+    request.
+
+    This function then sets up three endpoints:
+    - POST {path_prefix}: To request the execution of the tool (the 'job')
+    - GET {path_prefix}/{job_id}: To collect the result of a tool execution
+    - GET {path_prefix}: To obtain a description of the tool suitable for most agent frameworks
+
+    The POST request will only wait `opts.max_wait_time` for the tool to finish. If it
+    hasn't finished by then, a `204 No Content` code will be returned with additional
+    header fields `Location` and `Retry-later` to inform the caller where and approx.
+    when the result can be collected later.
+
+    The `opts` parameter allows for customization of the endpoints. See `ToolOptions`
+    for a more detailed description.
+
+    Args:
+        app (FastAPI): The FastAPI context
+        path_prefix (str): The path prefix to use for this set of endpoints
+        worker_fn (Callable[[BaseModel, Optional[ExecutionContext], Optional[Response]], BaseModel]): _description_
+        opts (Optional[ToolOptions], optional): Additional behaviour settings. Defaults to ToolOptions().
+        context (Optional[ExecutionContext], optional): An optional context to be provided to every invocation of `worker_fn`. Defaults to None.
+    """
+    def_name, def_tag = get_title_from_path(path_prefix)
+    if opts.tags is None:
+        if def_tag == '':
+            def_tag = "Tool"
+        opts.tags = [def_tag]
+    if opts.name is None:
+        if def_name == '':
+            def_name = "Execute the tool"
+        opts.name = def_name
+
+    output_model = get_function_return_type(worker_fn)
+    executor = Executor[output_model](worker_fn, opts=opts.executor_opts, context=context)
+
+    tools.append(ToolDescription(name=worker_fn.__name__,
+                                path_prefix=path_prefix,
+                                worker_fn=worker_fn,
+                                input=get_input_type(worker_fn),
+                                executor=executor))
+
+    _add_do_job_route(app, path_prefix, worker_fn, executor, opts)
+    _add_get_job_route(app, path_prefix, worker_fn, executor, opts)
+    _add_get_tool_def_route(app, path_prefix, worker_fn, opts)
+
+def _add_do_job_route(app: FastAPI, path_prefix: str, worker_fn: Callable, executor: Executor, opts: ToolOptions):
+    input_model, _ = get_input_type(worker_fn)
+    output_model = get_function_return_type(worker_fn)
+    summary, description = (worker_fn.__doc__.lstrip() + "\n").split("\n", 1)
+
+    async def route(data: input_model, req: Request) -> output_model:  # type: ignore
+        job_id = req.headers.get("job-id")
+        if job_id == None:
+            job_id = str(uuid6())
+        elif job_id.startswith(JOB_URN_PREFIX):
+            job_id = job_id[len(JOB_URN_PREFIX):]
+
+        if req.headers.get("prefer") == "respond-async":
+            timeout = 0
+        else:
+            toh = req.headers.get("timeout")
+            if toh != None:
+                timeout = int(toh)
+            else:
+                timeout = opts.max_wait_time
+        logger.info(f"starting job {path_prefix}/jobs/{job_id} - timeout: {timeout} seconds")
+
+        queue = await executor.execute(data, job_id, req)
+        try:
+            el = await asyncio.wait_for(queue.get(), timeout=timeout)
+            queue.task_done()
+            el = _return_job_result(el, job_id)
+            return el
+        except asyncio.TimeoutError:
+            logger.info(f"... defer job result to later - {job_id}")
+            return _return_try_later(job_id, path_prefix, opts)
+
+    responses = {
+        204: {
+            "headers": {
+                "Location": {
+                    "description": "The URL where to pick up the result of this request",
+                    "type": "string",
+                },
+                "Retry-Later": {
+                    "description": "The time to wait before checking for a result",
+                    "type": "integer",
+                },
+            },
+        },
+        400: { "model": ErrorModel, },
+        # 400: {"model": Error}, 401: {"model": Error}, 429: {"model": Error}},
+    }
+    app.add_api_route(
+        path_prefix,
+        route,
+        # name=opts.name,
+        summary=summary,
+        description=description.strip(),
+        methods=["POST"],
+        responses=responses,
+        tags=opts.tags,
+        response_model_exclude_none=True,
+        response_model_by_alias=True,
+        **opts.post_route_opts,
+    )
+
+def _add_get_job_route(app: FastAPI, path_prefix: str, worker_fn: Callable, executor: Executor, opts: ToolOptions):
+    output_model = get_function_return_type(worker_fn)
+    def route(job_id: str) -> output_model: # type: ignore
+        if job_id.startswith(JOB_URN_PREFIX):
+            job_id = job_id[len(JOB_URN_PREFIX):]
+        try:
+            result = executor.lookup_job(job_id)
+            if result == None:
+                return _return_try_later(job_id, path_prefix, opts)
+            return _return_job_result(result, job_id)
+        except KeyError:
+            return Response(status_code=status.HTTP_404_NOT_FOUND,
+                            content=f"job {job_id} can't be found. It either never existed or its result is no longer cached.")
+
+    responses = {
+        400: { "model": ErrorModel, },
+    }
+    path = "/jobs/" + "{job_id}"
+    if path_prefix != "/":
+        path = path_prefix + path
+    app.add_api_route(
+        path,
+        route,
+        summary="Returns the result of a particular job.",
+        methods=["GET"],
+        responses=responses,
+        tags=opts.tags,
+        response_model_exclude_none=True,
+        response_model_by_alias=True,
+    )
+
+def _return_job_result(el, job_id):
+    h = { "job-id": JOB_URN_PREFIX + job_id }
+    if isinstance(el, IvcapResult):
+        return  Response(status_code=status.HTTP_200_OK, content=el.content, media_type=el.content_type, headers=h)
+    elif isinstance(el, ExecutionError):
+        if el.type == ValueError:
+            m = ErrorModel(message=el.error, code=400)
+            status_code=status.HTTP_400_BAD_REQUEST
+        else:
+            m = ExecutionErrorModel(message=el.error, traceback=el.traceback)
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+
+        return Response(status_code=status_code, content=m.model_dump_json(indent=2), media_type="application/json", headers=h)
+
+    msg = json.dumps({"error": f"please report unexpected internal error - unexpected result type {type(el)}"})
+    return  Response(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=msg, media_type="application/json", headers=h)
+
+
+def _add_get_tool_def_route(app: FastAPI, path_prefix: str, worker_fn: Callable, opts: ToolOptions):
+    async def route(req: Request) -> ToolDefinition:  # type: ignore
+        service_id = opts.service_id
+        if service_id != None and service_id.startswith("/"):
+            # check if there is a forwarded header and prepand that
+            prefix = get_public_url_prefix(req)
+            service_id = f"{prefix}{service_id}"
+
+        return create_tool_definition(worker_fn, service_id=service_id)
+
+    app.add_api_route(
+        path_prefix,
+        route,
+        summary="Returns the description of this tool. Primarily used by agents.",
+        methods=["GET"],
+        tags=opts.tags,
+        response_model_exclude_none=True,
+        response_model_by_alias=True,
+    )
+
+
+def _return_try_later(job_id: str, path_prefix: str, opts: ToolOptions):
+    location = f"/jobs/{job_id}"
+    if path_prefix != "/":
+        location = path_prefix + location
+    headers = {
+        "Location": location,
+        "Retry-Later": f"{opts.refresh_interval}",
+        "Ivcap-Self-Report-Result": "true"
+    }
+    return Response(status_code=status.HTTP_204_NO_CONTENT, headers=headers)

ivcap_lambda/decorators.py

@@ -0,0 +1,60 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+from typing import Optional
+
+from .builder import ToolOptions, add_tool_api_route, WorkerFn
+from .executor import ExecutionContext
+from .server import get_fast_app
+
+
+def ivcap_lambda(
+    path_prefix: str,
+    *,
+    opts: Optional[ToolOptions] = ToolOptions(),
+    context: Optional[ExecutionContext] = None,
+):
+    """Add a few routes to the service for use with an AI tool.
+
+    The tool itself is implemented in `worker_fn` where the first
+    argument is a pydantic model describing all the tool's "public" parameters.
+    The function is also expected to return it's result as a single pydantic model.
+    The tool function can have two optioanl paramters, one with the same type as
+    `context` and the second one with `fastapi.Request`. The context paramter will
+    be identical to the above `context`, while the `request` will be the incoming
+    request.
+
+    This function then sets up three endpoints:
+    - POST {path_prefix}: To request the execution of the tool (the 'job')
+    - GET {path_prefix}/{job_id}: To collect the result of a tool execution
+    - GET {path_prefix}: To obtain a description of the tool suitable for most agent frameworks
+
+    The POST request will only wait `opts.max_wait_time` for the tool to finish. If it
+    hasn't finished by then, a `204 No Content` code will be returned with additional
+    header fields `Location` and `Retry-later` to inform the caller where and approx.
+    when the result can be collected later.
+
+    The `opts` parameter allows for customization of the endpoints. See `ToolOptions`
+    for a more detailed description.
+
+    Args:
+        path_prefix (str): The path prefix to use for this set of endpoints
+        opts (Optional[ToolOptions], optional): Additional behaviour settings. Defaults to ToolOptions().
+        context (Optional[ExecutionContext], optional): An optional context to be provided to every invocation of `worker_fn`. Defaults to None.
+    """
+
+    def decorator(worker_fn: WorkerFn):
+        """
+        Args:
+        worker_fn (Callable[[BaseModel, Optional[ExecutionContext], Optional[Response]], BaseModel]): _description_
+        opts (Optional[ToolOptions], optional): Additional behaviour settings. Defaults to ToolOptions().
+        context (Optional[ExecutionContext], optional): An optional context to be provided to every invocation of `worker_fn`. Defaults to None.
+        """
+        add_tool_api_route(
+            get_fast_app(), path_prefix, worker_fn, opts=opts, context=context
+        )
+        return worker_fn
+
+    return decorator

ivcap_lambda/executor.py

@@ -0,0 +1,292 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import asyncio
+import contextvars
+import concurrent.futures
+import threading
+from time import sleep
+import traceback
+import contextlib
+from typing import Any, Callable, Generic, List, Optional, TypeVar, Union
+from cachetools import TTLCache
+from fastapi import Request
+from pydantic import BaseModel, Field
+from ivcap_service import getLogger
+from opentelemetry import trace, context
+from opentelemetry.context.context import Context
+
+from ivcap_service import get_input_type, push_result, verify_result, EventReporter
+from ivcap_service import ExecutionError, create_event_reporter, JobContext
+from ivcap_client import IVCAP
+
+# Number of attempt to deliver job result before giving up
+MAX_DELIVER_RESULT_ATTEMPTS = 4
+
+logger = getLogger("executor")
+tracer = trace.get_tracer("executor")
+
+
+class ExecutionContext:
+    pass
+
+
+class ThreadLocal(threading.local):
+    pass
+
+
+T = TypeVar("T")
+
+
+class ExecutorOpts(BaseModel):
+    job_cache_size: Optional[int] = Field(10000, description="size of job cache")
+    job_cache_ttl: Optional[int] = Field(
+        3600, description="TTL of job entries in the job cache"
+    )
+    max_workers: Optional[int] = Field(
+        None,
+        description="size of thread pool to use. If None, a new thread pool will be created for each execution",
+    )
+
+
+job_context: contextvars.ContextVar[Optional[JobContext]] = contextvars.ContextVar(
+    "ivcap", default=None
+)
+
+
+def get_job_context() -> Optional[JobContext]:
+    return job_context.get()
+
+
+def get_event_reporter() -> Optional[EventReporter]:
+    """Get the current event reporter from the job context."""
+    jctxt = job_context.get()
+    return jctxt.report if jctxt is not None else None
+
+
+def get_job_id() -> Optional[str]:
+    """Get the current job ID from the job context."""
+    jctxt = job_context.get()
+    return jctxt.job_id if jctxt is not None else None
+
+
+class Executor(Generic[T]):
+    """
+    A generic class that executes a function in a thread pool and returns the result via an asyncio Queue.
+    The generic type T represents the return type of the function.
+    """
+
+    # _job_ctxt = JobContext()
+    _active_jobs = (
+        set()
+    )  # keep track of active jobs to block shutdown until they are done
+
+    @classmethod
+    def active_jobs(cls) -> List[str]:
+        """Returns a list of IDs of the currently active jobs"""
+        return list(cls._active_jobs)
+
+    @classmethod
+    def wait_for_exit_ready(cls):
+        """The server is calling this method when a shutdown request arrived. It will
+        proceed with the shutdown when this method returns.
+
+        We may implement functionality to only return when all active jobs have finsihed, as well as not
+        accepting any new incoming requests.
+        """
+        while len(cls._active_jobs) > 0:
+            logger.info(
+                f"blocking shutdown as {len(cls._active_jobs)} job(s) are still running"
+            )
+            sleep(5)
+        return
+
+    def __init__(
+        self,
+        func: Callable[..., T],
+        *,
+        opts: Optional[ExecutorOpts],
+        context: Optional[JobContext] = None,
+    ):
+        """
+        Initialize the Executor with a function and an optional thread pool.
+
+        Args:
+            func: The function to execute, returning type T
+            opts:
+             - job_cache_size: Optional size of job cache. Defaults to 1000
+             - job_cache_ttl: Optional TTL of job entries in the job cache. Defaults to 600 sec
+             - max_workers: Optional size of thread pool to use. If None, a new thread pool will be created for each execution.
+        """
+        self.func = func
+        if opts is None:
+            opts = ExecutorOpts()
+        self.job_cache = TTLCache(maxsize=opts.job_cache_size, ttl=opts.job_cache_ttl)
+        self.thread_pool = None
+        if opts.max_workers:
+            self.thread_pool = concurrent.futures.ThreadPoolExecutor(
+                max_workers=opts.max_workers
+            )
+
+        self.context = context
+        self.context_param = None
+        self.request_param = None
+        self.job_ctxt_param = None
+        _, extras = get_input_type(func)
+        for k, v in extras.items():
+            if isinstance(context, v):
+                self.context_param = k
+            elif v == Request:
+                self.request_param = k
+            elif v == JobContext:
+                self.job_ctxt_param = k
+            else:
+                raise Exception(f"unexpected function parameter '{k}'")
+
+    async def execute(
+        self, param: Any, job_id: str, req: Request, report_result=True
+    ) -> asyncio.Queue[Union[T, ExecutionError]]:
+        """
+        Execute the function with the given parameter in a thread and return a queue with the result.
+
+        Args:
+            param: Any The parameter to pass to the function
+            job_id: str ID of this job
+            req: Request FastAPI's request object
+
+        Returns:
+            An asyncio Queue that will contain either the result of type T or an ExecutionError
+        """
+        result_queue: asyncio.Queue[Union[T, ExecutionError]] = asyncio.Queue()
+        event_loop = asyncio.get_running_loop()
+        self.job_cache[job_id] = None
+
+        def _process_result(result):
+            """Verify the result, add it to the queue, and report it to IVCAP."""
+            try:
+                result = verify_result(result, job_id, logger)
+            except Exception as e:
+                result = ExecutionError(
+                    error=str(e),
+                    type=type(e).__name__,
+                    traceback=traceback.format_exc(),
+                )
+                logger.warning(f"job {job_id} failed - {result.error}")
+            finally:
+                self.job_cache[job_id] = result
+                logger.info(f"job {job_id} finished, sending result message")
+                asyncio.run_coroutine_threadsafe(
+                    result_queue.put(result),
+                    event_loop,
+                )
+                if report_result:
+                    push_result(result, job_id)
+                self.__class__._active_jobs.discard(job_id)
+
+        def _run(param: Any, ctxt: Context):
+            context.attach(ctxt)  # OTEL
+            authorization = req.headers.get("authorization")
+            jctxt = JobContext(
+                job_id=job_id,
+                job_authorization=authorization,
+                report=create_event_reporter(
+                    job_id=job_id, job_authorization=authorization
+                ),
+            )
+            job_context.set(jctxt)
+            kwargs = {}
+            if self.context_param is not None:
+                kwargs[self.context_param] = self.context
+            if self.request_param is not None:
+                kwargs[self.request_param] = req
+            if self.job_ctxt_param is not None:
+                kwargs[self.job_ctxt_param] = jctxt  # self._job_ctxt
+
+            fname = self.func.__name__
+            with tracer.start_as_current_span(f"RUN {fname}") as span:
+                span.set_attribute("job.id", job_id)
+                span.set_attribute("job.name", fname)
+                loop = None
+                try:
+                    self.__class__._active_jobs.add(job_id)
+                    if asyncio.iscoroutinefunction(self.func):
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                        try:
+                            res = loop.run_until_complete(self.func(param, **kwargs))
+                        except (asyncio.CancelledError, GeneratorExit):
+                            # Propagate cancellation and generator shutdown properly
+                            raise
+                        finally:
+                            # Gracefully shutdown remaining tasks and async generators to avoid
+                            # 'Task exception was never retrieved' and similar warnings
+                            try:
+                                pending = [
+                                    t for t in asyncio.all_tasks(loop) if not t.done()
+                                ]
+                                for t in pending:
+                                    t.cancel()
+                                if pending:
+                                    with contextlib.suppress(Exception):
+                                        loop.run_until_complete(
+                                            asyncio.gather(
+                                                *pending, return_exceptions=True
+                                            )
+                                        )
+                                with contextlib.suppress(Exception):
+                                    loop.run_until_complete(loop.shutdown_asyncgens())
+                            finally:
+                                loop.close()
+                    else:
+                        res = self.func(param, **kwargs)
+                except (asyncio.CancelledError, GeneratorExit):
+                    # Allow cooperative shutdown/cancellation to propagate cleanly
+                    span.record_exception(Exception("cancelled"))
+                    raise
+                except Exception as ex:
+                    span.record_exception(ex)
+                    logger.error(
+                        f"while executing {job_id} - {type(ex).__name__}: {ex}"
+                    )
+                    res = ExecutionError(
+                        error=str(ex),
+                        type=type(ex).__name__,
+                        traceback=traceback.format_exc(),
+                    )
+                finally:
+                    self.__class__._active_jobs.discard(job_id)
+
+                try:
+                    _process_result(res)
+                except Exception as ex:
+                    logger.error(f"while delivering result fo {job_id} - {ex}")
+
+                job_context.set(None)
+
+        # Use the provided thread pool or create a new one
+        use_pool = self.thread_pool or concurrent.futures.ThreadPoolExecutor(
+            max_workers=1
+        )
+        # Submit the function to the thread pool
+        future = use_pool.submit(_run, param, context.get_current())
+
+        # If we created a new pool, we should clean it up when done
+        if self.thread_pool is None:
+            future.add_done_callback(lambda _: use_pool.shutdown(wait=False))
+        return result_queue
+
+    def lookup_job(self, job_id: str) -> Union[T, ExecutionError, None]:
+        """Return the result of a job
+
+        Args:
+            job_id (str): The id of the job requested
+
+        Returns:
+            Union[T, ExecutionError, None]: Returns the result fo a job, 'None' is still in progress
+
+        Raises:
+            KeyError: Unknown job - may have already expired
+        """
+        return self.job_cache[job_id]

ivcap_lambda/logger.py

@@ -0,0 +1,37 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import json
+import os
+import logging
+from ivcap_service import set_service_log_config
+
+class SuppressPathsFilter(logging.Filter):
+    def __init__(self, targets=None):
+        super().__init__()
+        if targets is None:
+            self.targets = []
+        else:
+            self.targets = targets
+
+    def filter(self, record):
+        # Suppress logs for any request matching a target substring or path
+        # For uvicorn.access, HTTP info is in record.args: (client_addr, method, path, http_version, status)
+        path = ""
+        if hasattr(record, "args") and isinstance(record.args, tuple) and len(record.args) >= 3:
+            path = record.args[2]
+        for target in self.targets:
+            if target == path:
+                return False
+        return True
+
+def logging_init(cfg_path: str=None):
+    if not cfg_path:
+        script_dir = os.path.dirname(__file__)
+        cfg_path = os.path.join(script_dir, "logging.json")
+
+    with open(cfg_path, 'r') as file:
+        config = json.load(file)
+        set_service_log_config(config)