service-forge 0.1.18__py3-none-any.whl → 0.1.39__py3-none-any.whl

service_forge/sft/config/injector.py

@@ -2,9 +2,9 @@ import yaml
 from pathlib import Path
 from service_forge.sft.util.logger import log_info, log_error
 from service_forge.sft.config.injector_default_files import *
-from service_forge.sft.config.sf_metadata import load_metadata
+from service_forge.sft.config.sf_metadata import load_metadata, save_metadata
 from service_forge.sft.config.sft_config import sft_config
-from service_forge.service_config import ServiceConfig, ServiceFeedbackConfig
+from service_forge.service_config import ServiceConfig, ServiceFeedbackConfig, SignozConfig, TraceConfig
 from service_forge.sft.util.name_util import get_service_name
 from service_forge.sft.util.yaml_utils import load_sf_metadata_as_string
 
@@ -16,7 +16,9 @@ class Injector:
         self.ingress_yaml_path = project_dir / "ingress.yaml"
         self.dockerfile_path = project_dir / "Dockerfile"
         self.pyproject_toml_path = project_dir / "pyproject.toml"
+        self.start_sh_path = project_dir / "start.sh"
         self.metadata = load_metadata(self.metadata_path)
+        self.metadata.mode = "release"
         self.name = self.metadata.name
         self.version = self.metadata.version
         self.namespace = sft_config.k8s_namespace
@@ -93,6 +95,32 @@ class Injector:
                 api_timeout=sft_config.inject_feedback_api_timeout,
             )
 
+        if config.signoz is not None:
+            config.signoz.api_url = sft_config.inject_signoz_api_url
+            config.signoz.api_key = sft_config.inject_signoz_api_key
+        else:
+            config.signoz = SignozConfig(
+                api_url=sft_config.inject_signoz_api_url,
+                api_key=sft_config.inject_signoz_api_key,
+            )
+
+        if config.trace is not None:
+            config.trace.enable = True
+            config.trace.url = sft_config.inject_trace_url
+            config.trace.headers = sft_config.inject_trace_headers
+            config.trace.arg = sft_config.inject_trace_arg
+            config.trace.namespace = sft_config.inject_trace_namespace
+            config.trace.hostname = sft_config.inject_trace_hostname
+        else:
+            config.trace = TraceConfig(
+                enable=True,
+                url=sft_config.inject_trace_url,
+                headers=sft_config.inject_trace_headers,
+                arg=sft_config.inject_trace_arg,
+                namespace=sft_config.inject_trace_namespace,
+                hostname=sft_config.inject_trace_hostname,
+            )
+
         with open(service_config_path, "w", encoding="utf-8") as f:
             yaml.dump(config.model_dump(), f, allow_unicode=True, indent=2)
 
@@ -121,9 +149,28 @@ class Injector:
                 f.write(pyproject_toml)
         print("pyproject_toml_path: ", self.pyproject_toml_path)
 
+    def clear_start_sh(self) -> None:
+        if Path(self.start_sh_path).exists():
+            with open(self.start_sh_path, "rb") as f:
+                content = f.read()
+            content_str = content.decode("utf-8")
+            lines = content_str.splitlines()
+            new_content = "\n".join(lines) + ("\n" if content_str.endswith(('\n', '\r')) else "")
+            with open(self.start_sh_path, "w", encoding="utf-8", newline="\n") as f:
+                f.write(new_content)
+
     def inject(self) -> None:
-        self.inject_deployment()
-        self.inject_service_config()
-        self.inject_ingress()
-        self.inject_dockerfile()
-        self.inject_pyproject_toml()
+        if self.metadata.inject.pyproject_toml:
+            self.inject_pyproject_toml()
+        if self.metadata.inject.deployment:
+            self.inject_deployment()
+        if self.metadata.inject.service_config:
+            self.inject_service_config()
+        if self.metadata.inject.ingress:
+            self.inject_ingress()
+        if self.metadata.inject.dockerfile:
+            self.inject_dockerfile()
+        if self.metadata.inject.pyproject_toml:
+            self.inject_pyproject_toml()
+        self.clear_start_sh()
+        save_metadata(self.metadata, self.metadata_path)

service_forge/sft/config/injector_default_files.py

@@ -65,6 +65,18 @@ spec:
   entryPoints:
     - web
   routes:
+    - match: PathPrefix(`/api/v1/{name}-{version}/sdk`)
+      kind: Rule
+      services:
+        - name: sf-{name}-{version}v
+          namespace: {namespace}
+          port: 80
+      middlewares:
+        - name: strip-prefix-sf-{name}-{version}v
+          namespace: {namespace}
+        - name: cors
+          namespace: {namespace}
+
     - match: PathPrefix(`/api/v1/{name}-{version}/openapi.json`)
       kind: Rule
       services:
@@ -128,4 +140,4 @@ DEFAULT_PYPROJECT_TOML = """
 
 [tool.uv.sources]
 service-forge = { workspace = true }
-"""
+"""

service_forge/sft/config/sf_metadata.py

@@ -1,30 +1,34 @@
-from omegaconf import OmegaConf
+from __future__ import annotations
+import yaml
+from pydantic import BaseModel
 
-class SfMetadata:
-    def __init__(
-        self,
-        name: str,
-        version: str,
-        description: str,
-        service_config: str,
-        config_only: bool,
-        env: list[dict],
-    ) -> None:
-        self.name = name
-        self.version = version
-        self.description = description
-        self.service_config = service_config
-        self.config_only = config_only
-        self.env = env
+class SfMetadataInject(BaseModel):
+    deployment: bool = True
+    service_config: bool = True
+    ingress: bool = True
+    dockerfile: bool = True
+    pyproject_toml: bool = True
+
+class SfMetadata(BaseModel):
+    name: str
+    version: str
+    description: str
+    service_config: str
+    config_only: bool
+    env: list[dict]
+    inject: SfMetadataInject = SfMetadataInject()
+    enable_auth_middleware: bool = True
+    mode: str = "debug"
+
+    @classmethod
+    def from_yaml_file(cls, filepath: str) -> SfMetadata:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+        return cls(**data)
 
 def load_metadata(path: str) -> SfMetadata:
-    with open(path, 'r') as file:
-        data = OmegaConf.load(file)
-        return SfMetadata(
-            name=data.get('name'),
-            version=data.get('version'),
-            description=data.get('description'),
-            service_config=data.get('service_config'),
-            config_only=data.get('config_only'),
-            env=data.get('env', []),
-        )
+    return SfMetadata.from_yaml_file(path)
+
+def save_metadata(meta: SfMetadata, path: str) -> None:
+    with open(path, 'w', encoding='utf-8') as f:
+        yaml.safe_dump(meta.model_dump(), f, allow_unicode=True)

service_forge/sft/config/sft_config.py

@@ -57,6 +57,15 @@ class SftConfig:
         inject_feedback_api_url: str = "http://vps.shiweinan.com:37919/api/v1/feedback",
         inject_feedback_api_timeout: int = 5,
 
+        inject_signoz_api_url: str = "http://signoz.vps.shiweinan.com:37919",
+        inject_signoz_api_key: str = "JlxvqRtNFu5yc4o1bRcJyzeolA96iWzAyQnBePRRJd0=",
+
+        inject_trace_url: str = "http://traces.vps.shiweinan.com:37919/v1/traces",
+        inject_trace_headers: str = "",
+        inject_trace_arg: float = 1.0,
+        inject_trace_namespace: str = "secondbrain",
+        inject_trace_hostname: str = "",
+
         deepseek_api_key: str = "82c9df22-f6ed-411e-90d7-c5255376b7ca",
         deepseek_base_url: str = "https://ark.cn-beijing.volces.com/api/v3",
     ):
@@ -88,6 +97,15 @@ class SftConfig:
         self.inject_feedback_api_url = inject_feedback_api_url
         self.inject_feedback_api_timeout = inject_feedback_api_timeout
 
+        self.inject_signoz_api_url = inject_signoz_api_url
+        self.inject_signoz_api_key = inject_signoz_api_key
+
+        self.inject_trace_url = inject_trace_url
+        self.inject_trace_headers = inject_trace_headers
+        self.inject_trace_arg = inject_trace_arg
+        self.inject_trace_namespace = inject_trace_namespace
+        self.inject_trace_hostname = inject_trace_hostname
+
         self.deepseek_api_key = deepseek_api_key
         self.deepseek_base_url = deepseek_base_url
 

service_forge/sft/util/assert_util.py

@@ -2,7 +2,6 @@ import typer
 from pathlib import Path
 from typing import Callable, TypeVar, Any
 from service_forge.sft.util.logger import log_error, log_info
-from service_forge.sft.config.sf_metadata import load_metadata, SfMetadata
 
 T = TypeVar('T')
 

service_forge/telemetry.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from loguru import logger
+from opentelemetry import trace
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace.sampling import ParentBased, TraceIdRatioBased
+from service_forge.service_config import TraceConfig
+
+_initialized = False
+
+def _parse_headers(raw: Optional[str]) -> dict[str, str]:
+    if not raw:
+        return {}
+    headers: dict[str, str] = {}
+    for part in raw.split(","):
+        if "=" in part:
+            key, value = part.split("=", 1)
+            headers[key.strip()] = value.strip()
+    return headers
+
+
+def setup_tracing(service_name: Optional[str] = None, config: TraceConfig = None) -> None:
+    """Initialize a global tracer provider with OTLP exporter if not already configured."""
+    if config is None or not config.enable:
+        return
+
+    global _initialized
+    if _initialized:
+        return
+
+    service_name = service_name or "service_forge_service"
+    endpoint = config.url
+    headers = _parse_headers(config.headers)
+
+    sampler_arg = config.arg or 1.0
+    try:
+        ratio = float(sampler_arg)
+    except ValueError:
+        ratio = 1.0
+    sampler = ParentBased(TraceIdRatioBased(ratio))
+
+    resource = Resource.create(
+        {
+            "service.name": service_name,
+            "service.namespace": config.namespace or "secondbrain",
+            "service.instance.id": config.hostname or "",
+        }
+    )
+
+    try:
+        provider = TracerProvider(resource=resource, sampler=sampler)
+        exporter = OTLPSpanExporter(endpoint=endpoint, headers=headers)
+        processor = BatchSpanProcessor(exporter)
+        provider.add_span_processor(processor)
+        trace.set_tracer_provider(provider)
+        _initialized = True
+        logger.info(
+            f"Tracing initialized: endpoint={endpoint}, service={service_name}, ratio={ratio}"
+        )
+    except Exception as exc:
+        logger.warning(f"Tracing initialization failed: {exc}")

service_forge/utils/default_type_converter.py

@@ -2,8 +2,8 @@ from ..utils.type_converter import TypeConverter
 from ..workflow.workflow import Workflow
 from ..api.http_api import fastapi_app
 from ..api.kafka_api import KafkaApp, kafka_app
-from fastapi import FastAPI
 from ..workflow.workflow_type import WorkflowType, workflow_type_register
+from fastapi import FastAPI
 
 type_converter = TypeConverter()
 type_converter.register(str, Workflow, lambda s, node: node.sub_workflows.get_workflow(s))

service_forge/utils/type_converter.py

@@ -1,6 +1,8 @@
 from typing import Any, Callable, Type, Dict, Tuple, Set, List
 from collections import deque
 import inspect
+import traceback
+from pydantic import BaseModel
 from typing_extensions import get_origin, get_args
 
 def is_type(value, dst_type):
@@ -57,6 +59,9 @@ class TypeConverter:
         except Exception:
             pass
 
+        if issubclass(dst_type, BaseModel) and isinstance(value, dict):
+            return dst_type(**value)
+
         path = self._find_path(src_type, dst_type)
         if not path:
             raise TypeError(f"No conversion path found from {src_type.__name__} to {dst_type.__name__}.")

service_forge/utils/workflow_clone.py

@@ -69,6 +69,7 @@ def workflow_clone(self: Workflow, task_id: uuid.UUID, trigger_node: Trigger) ->
         callbacks=self.callbacks,
         task_id=task_id,
         real_trigger_node=trigger_node,
+        global_context=self.global_context,
     )
 
     for node in workflow.nodes: