239 lines
10 KiB
Python
239 lines
10 KiB
Python
import os
|
|
import sys
|
|
from typing import Optional
|
|
from pydantic_settings import BaseSettings
|
|
from pydantic import validator, ConfigDict
|
|
from loguru import logger
|
|
from watchfiles import watch, Change
|
|
from threading import Thread
|
|
from langfuse import Langfuse
|
|
from langfuse.langchain import CallbackHandler
|
|
import yaml
|
|
from pathlib import Path
|
|
|
|
class LangfuseConfig(BaseSettings):
|
|
enabled: bool = True
|
|
public_key: Optional[str] = None
|
|
secret_key: Optional[str] = None
|
|
host: Optional[str] = None
|
|
|
|
@validator('host')
|
|
def validate_host(cls, v):
|
|
if v and not v.startswith(('http://', 'https://')):
|
|
raise ValueError("Langfuse host must start with http:// or https://")
|
|
return v
|
|
|
|
def __init__(self, **data):
|
|
try:
|
|
logger.info("Initializing LangfuseConfig with data: {}", data)
|
|
logger.info("Environment variables:")
|
|
logger.info("LANGFUSE_PUBLIC_KEY: {}", os.getenv('LANGFUSE_PUBLIC_KEY'))
|
|
logger.info("LANGFUSE_SECRET_KEY: {}", os.getenv('LANGFUSE_SECRET_KEY'))
|
|
logger.info("LANGFUSE_HOST: {}", os.getenv('LANGFUSE_HOST'))
|
|
|
|
super().__init__(**data)
|
|
logger.info("LangfuseConfig initialized successfully")
|
|
logger.info("Public Key: {}", self.public_key)
|
|
logger.info("Secret Key: {}", self.secret_key)
|
|
logger.info("Host: {}", self.host)
|
|
except Exception as e:
|
|
logger.error("Failed to initialize LangfuseConfig: {}", e)
|
|
logger.error("Current environment variables:")
|
|
logger.error("LANGFUSE_PUBLIC_KEY: {}", os.getenv('LANGFUSE_PUBLIC_KEY'))
|
|
logger.error("LANGFUSE_SECRET_KEY: {}", os.getenv('LANGFUSE_SECRET_KEY'))
|
|
logger.error("LANGFUSE_HOST: {}", os.getenv('LANGFUSE_HOST'))
|
|
raise
|
|
|
|
model_config = ConfigDict(
|
|
env_prefix='LANGFUSE_',
|
|
env_file='.env',
|
|
env_file_encoding='utf-8',
|
|
extra='ignore',
|
|
env_nested_delimiter='__',
|
|
case_sensitive=True
|
|
)
|
|
|
|
class LogConfig(BaseSettings):
|
|
level: str = 'INFO'
|
|
|
|
model_config = ConfigDict(
|
|
env_prefix='LOG_',
|
|
extra='ignore'
|
|
)
|
|
|
|
class LLMConfig(BaseSettings):
|
|
mode: str = 'ollama'
|
|
|
|
# OpenAI settings
|
|
openai_api_key: Optional[str] = None
|
|
openai_api_base_url: Optional[str] = None
|
|
openai_model: Optional[str] = None
|
|
|
|
# Ollama settings
|
|
ollama_base_url: Optional[str] = None
|
|
ollama_model: Optional[str] = None
|
|
|
|
@validator('mode')
|
|
def validate_mode(cls, v):
|
|
if v not in ['openai', 'ollama']:
|
|
raise ValueError("LLM mode must be either 'openai' or 'ollama'")
|
|
return v
|
|
|
|
model_config = ConfigDict(
|
|
env_prefix='LLM_',
|
|
env_file='.env',
|
|
env_file_encoding='utf-8',
|
|
extra='ignore'
|
|
)
|
|
|
|
class Settings:
|
|
def __init__(self):
|
|
try:
|
|
logger.info("Loading configuration from application.yml and environment variables")
|
|
|
|
# Load configuration from YAML file
|
|
yaml_config = self._load_yaml_config()
|
|
logger.info("Loaded YAML config: {}", yaml_config) # Add this log line
|
|
|
|
# Initialize configurations, allowing environment variables to override YAML
|
|
logger.info("Initializing LogConfig")
|
|
self.log = LogConfig(**yaml_config.get('log', {}))
|
|
logger.info("LogConfig initialized: {}", self.log.model_dump())
|
|
|
|
logger.info("Initializing LLMConfig")
|
|
self.llm = LLMConfig(**yaml_config.get('llm', {}))
|
|
logger.info("LLMConfig initialized: {}", self.llm.model_dump())
|
|
|
|
logger.info("Initializing LangfuseConfig")
|
|
self.langfuse = LangfuseConfig(**yaml_config.get('langfuse', {}))
|
|
logger.info("LangfuseConfig initialized: {}", self.langfuse.model_dump())
|
|
|
|
logger.info("Validating configuration")
|
|
self._validate()
|
|
logger.info("Starting config watcher")
|
|
self._start_watcher()
|
|
logger.info("Initializing Langfuse")
|
|
self._init_langfuse()
|
|
logger.info("Configuration initialized successfully")
|
|
except Exception as e:
|
|
logger.error("Configuration initialization failed: {}", e)
|
|
logger.error("Current configuration state:")
|
|
logger.error("LogConfig: {}", self.log.model_dump() if hasattr(self, 'log') else 'Not initialized')
|
|
logger.error("LLMConfig: {}", self.llm.model_dump() if hasattr(self, 'llm') else 'Not initialized')
|
|
logger.error("LangfuseConfig: {}", self.langfuse.model_dump() if hasattr(self, 'langfuse') else 'Not initialized')
|
|
raise
|
|
|
|
def _load_yaml_config(self):
|
|
config_path = Path('/root/development/jira-webhook-llm/config/application.yml')
|
|
if not config_path.exists():
|
|
logger.warning("Configuration file not found at {}", config_path)
|
|
return {}
|
|
try:
|
|
with open(config_path, 'r') as f:
|
|
return yaml.safe_load(f) or {}
|
|
except Exception as e:
|
|
logger.error("Error loading configuration from {}: {}", config_path, e)
|
|
return {}
|
|
|
|
def _validate(self):
|
|
logger.info("LLM mode set to: '{}'", self.llm.mode)
|
|
|
|
if self.llm.mode == 'openai':
|
|
if not self.llm.openai_api_key:
|
|
raise ValueError("LLM mode is 'openai', but OPENAI_API_KEY is not set.")
|
|
if not self.llm.openai_api_base_url:
|
|
raise ValueError("LLM mode is 'openai', but OPENAI_API_BASE_URL is not set.")
|
|
if not self.llm.openai_model:
|
|
raise ValueError("LLM mode is 'openai', but OPENAI_MODEL is not set.")
|
|
elif self.llm.mode == 'ollama':
|
|
if not self.llm.ollama_base_url:
|
|
raise ValueError("LLM mode is 'ollama', but OLLAMA_BASE_URL is not set.")
|
|
if not self.llm.ollama_model:
|
|
raise ValueError("LLM mode is 'ollama', but OLLAMA_MODEL is not set.")
|
|
logger.info("Configuration validated successfully.")
|
|
|
|
def _init_langfuse(self):
|
|
if self.langfuse.enabled:
|
|
try:
|
|
# Verify all required credentials are present
|
|
if not all([self.langfuse.public_key, self.langfuse.secret_key, self.langfuse.host]):
|
|
raise ValueError("Missing required Langfuse credentials")
|
|
|
|
logger.debug("Initializing Langfuse client with:")
|
|
logger.debug("Public Key: {}", self.langfuse.public_key)
|
|
logger.debug("Secret Key: {}", self.langfuse.secret_key)
|
|
logger.debug("Host: {}", self.langfuse.host)
|
|
|
|
# Initialize Langfuse client
|
|
self.langfuse_client = Langfuse(
|
|
public_key=self.langfuse.public_key,
|
|
secret_key=self.langfuse.secret_key,
|
|
host=self.langfuse.host
|
|
)
|
|
|
|
# Test Langfuse connection
|
|
try:
|
|
self.langfuse_client.auth_check()
|
|
logger.debug("Langfuse connection test successful")
|
|
except Exception as e:
|
|
logger.error("Langfuse connection test failed: {}", e)
|
|
raise
|
|
|
|
# Initialize CallbackHandler
|
|
try:
|
|
self.langfuse_handler = CallbackHandler(
|
|
public_key=self.langfuse.public_key,
|
|
secret_key=self.langfuse.secret_key,
|
|
host=self.langfuse.host
|
|
)
|
|
except TypeError:
|
|
try:
|
|
# Fallback for older versions of langfuse.langchain.CallbackHandler
|
|
self.langfuse_handler = CallbackHandler(
|
|
public_key=self.langfuse.public_key,
|
|
host=self.langfuse.host
|
|
)
|
|
logger.warning("Using fallback CallbackHandler initialization - secret_key parameter not supported")
|
|
except TypeError:
|
|
# Fallback for even older versions
|
|
self.langfuse_handler = CallbackHandler(
|
|
public_key=self.langfuse.public_key
|
|
)
|
|
logger.warning("Using minimal CallbackHandler initialization - only public_key parameter supported")
|
|
logger.info("Langfuse client and handler initialized successfully")
|
|
|
|
logger.info("Langfuse client and handler initialized successfully")
|
|
except ValueError as e:
|
|
logger.warning("Langfuse configuration error: {}. Disabling Langfuse.", e)
|
|
self.langfuse.enabled = False
|
|
except Exception as e:
|
|
logger.error("Failed to initialize Langfuse: {}", e)
|
|
self.langfuse.enabled = False
|
|
|
|
def _start_watcher(self):
|
|
def watch_config():
|
|
for changes in watch('config/application.yml'):
|
|
for change in changes:
|
|
if change[0] == Change.modified:
|
|
logger.info("Configuration file modified, reloading settings...")
|
|
try:
|
|
# Reload YAML config and re-initialize all settings
|
|
yaml_config = self._load_yaml_config()
|
|
self.log = LogConfig(**yaml_config.get('log', {}))
|
|
self.llm = LLMConfig(**yaml_config.get('llm', {}))
|
|
self.langfuse = LangfuseConfig(**yaml_config.get('langfuse', {}))
|
|
self._validate()
|
|
self._init_langfuse() # Re-initialize Langfuse client if needed
|
|
logger.info("Configuration reloaded successfully")
|
|
except Exception as e:
|
|
logger.error("Error reloading configuration: {}", e)
|
|
|
|
Thread(target=watch_config, daemon=True).start()
|
|
|
|
# Create a single, validated instance of the settings to be imported by other modules.
|
|
try:
|
|
settings = Settings()
|
|
except ValueError as e:
|
|
logger.error("FATAL: {}", e)
|
|
logger.error("Application shutting down due to configuration error.")
|
|
sys.exit(1) |