dbt-logger 0.1.1__tar.gz

dbt_logger-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tristan Schwartz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dbt_logger-0.1.1/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.1
+Name: dbt-logger
+Version: 0.1.1
+Summary: A lightweight logging utility for dbt projects
+Home-page: https://github.com/TristanSchwartz/dbt-logger
+License: MIT
+Keywords: dbt,logging,data,analytics
+Author: Tristan Schwartz
+Requires-Python: >=3.9.2,<3.13
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: cryptography (>=41.0.0,<42.0.0)
+Requires-Dist: pyyaml (>=6.0.0,<7.0.0)
+Requires-Dist: snowflake-connector-python (>=3.0.0,<4.0.0)
+Project-URL: Repository, https://github.com/TristanSchwartz/dbt-logger
+Description-Content-Type: text/markdown
+
+# dbt-logger
+
+A logging utility that captures dbt command output and stores it in Snowflake for auditing and monitoring. **Uses your existing dbt credentials - no additional configuration needed!**
+
+## Installation
+
+```bash
+pip install dbt-logger
+```
+
+## Quick Start
+
+The simplest way - uses your existing dbt profiles.yml:
+
+```python
+from dbt_logger import DbtLogger
+
+# Automatically uses credentials from dbt profiles.yml
+logger = DbtLogger(repo_name="my_analytics_project")
+
+# Run dbt commands and log them
+logger.run_command("dbt build")
+logger.run_command("dbt run --select +sales_model")
+```
+
+That's it! Logs are automatically saved to `[your_dbt_database].logging.dbt_logging`
+
+## Configuration File (Optional)
+
+Create `dbt/dbt_logger.yml` in your dbt project to configure logging destination:
+
+```yaml
+# dbt/dbt_logger.yml
+
+# Option 1: Custom schema in dbt database
+schema: audit_logs
+
+# Option 2: Completely separate database for logs
+database: ADMIN_DB
+schema: LOGGING
+table_name: dbt_execution_logs
+```
+
+**Precedence order:**
+1. Parameters passed to `DbtLogger()` (highest)
+2. Settings in `dbt/dbt_logger.yml`
+3. Defaults: `{dbt_database}.logging.dbt_logging` (lowest)
+
+## Configuration Options
+
+### Use Specific dbt Profile/Target
+
+```python
+# Use a specific profile and target from profiles.yml
+logger = DbtLogger(
+    repo_name="my_project",
+    profile_name="my_profile",  # Optional: defaults to first profile
+    target="prod"                # Optional: defaults to profile's default target
+)
+```
+
+### Override Logging Location in Code
+
+```python
+# Override config file settings
+logger = DbtLogger(
+    repo_name="my_project",
+    database="ADMIN_DB",
+    schema="LOGGING",
+    table_name="my_custom_logs"
+)
+```
+
+### Manual Connection Parameters (Advanced)
+
+If you need to use different credentials than dbt:
+
+```python
+from dbt_logger import DbtLogger, get_connection_params_from_env
+
+# Option 1: From environment variables
+connection_params = get_connection_params_from_env()
+
+# Option 2: Manual dict
+connection_params = {
+    'account': 'your_account',
+    'user': 'your_user',
+    'password': 'your_password',
+    'database': 'your_database',
+    'warehouse': 'your_warehouse',
+}
+
+logger = DbtLogger(
+    repo_name="my_project",
+    connection_params=connection_params
+)
+```
+
+## How It Works
+
+1. **Reads your dbt profiles.yml** - Automatically finds and parses your dbt configuration
+2. **Supports private key auth** - Works with your existing DBT_USER, DBT_PVK_PATH, DBT_PVK_PASS env vars
+3. **Creates logging infrastructure** - Auto-creates schema and table on first run
+4. **Captures everything** - Runs dbt commands and logs all output in real-time
+5. **Stores in Snowflake** - Saves command history for auditing and monitoring
+
+## Logging Table Schema
+
+```sql
+-- Default location: [your_dbt_database].logging.dbt_logging
+CREATE TABLE dbt_logging (
+    repo_name STRING,      -- Your dbt project/repo name
+    command STRING,        -- The dbt command executed
+    stdout_log STRING,     -- Complete command output
+    log_time TIMESTAMP_LTZ -- Execution timestamp
+);
+```
+
+## dbt profiles.yml Locations
+
+The logger checks for profiles.yml in this order:
+1. `$DBT_PROFILES_DIR/profiles.yml`
+2. `./dbt/profiles/profiles.yml` (current directory)
+3. `~/.dbt/profiles.yml` (default dbt location)
+
+## Features
+
+- ✅ **Zero Config** - Uses your existing dbt credentials
+- ✅ **Private Key Auth** - Full support for private key authentication
+- ✅ **Auto Setup** - Creates schema and table automatically
+- ✅ **Real-time Output** - See command output live while logging
+- ✅ **Flexible Storage** - Default to dbt database or use separate logging database
+- ✅ **Environment Variables** - Resolves Jinja env_var() expressions from profiles.yml
+
+## License
+
+MIT License - see LICENSE file for details.

dbt_logger-0.1.1/README.md

@@ -0,0 +1,137 @@
+# dbt-logger
+
+A logging utility that captures dbt command output and stores it in Snowflake for auditing and monitoring. **Uses your existing dbt credentials - no additional configuration needed!**
+
+## Installation
+
+```bash
+pip install dbt-logger
+```
+
+## Quick Start
+
+The simplest way - uses your existing dbt profiles.yml:
+
+```python
+from dbt_logger import DbtLogger
+
+# Automatically uses credentials from dbt profiles.yml
+logger = DbtLogger(repo_name="my_analytics_project")
+
+# Run dbt commands and log them
+logger.run_command("dbt build")
+logger.run_command("dbt run --select +sales_model")
+```
+
+That's it! Logs are automatically saved to `[your_dbt_database].logging.dbt_logging`
+
+## Configuration File (Optional)
+
+Create `dbt/dbt_logger.yml` in your dbt project to configure logging destination:
+
+```yaml
+# dbt/dbt_logger.yml
+
+# Option 1: Custom schema in dbt database
+schema: audit_logs
+
+# Option 2: Completely separate database for logs
+database: ADMIN_DB
+schema: LOGGING
+table_name: dbt_execution_logs
+```
+
+**Precedence order:**
+1. Parameters passed to `DbtLogger()` (highest)
+2. Settings in `dbt/dbt_logger.yml`
+3. Defaults: `{dbt_database}.logging.dbt_logging` (lowest)
+
+## Configuration Options
+
+### Use Specific dbt Profile/Target
+
+```python
+# Use a specific profile and target from profiles.yml
+logger = DbtLogger(
+    repo_name="my_project",
+    profile_name="my_profile",  # Optional: defaults to first profile
+    target="prod"                # Optional: defaults to profile's default target
+)
+```
+
+### Override Logging Location in Code
+
+```python
+# Override config file settings
+logger = DbtLogger(
+    repo_name="my_project",
+    database="ADMIN_DB",
+    schema="LOGGING",
+    table_name="my_custom_logs"
+)
+```
+
+### Manual Connection Parameters (Advanced)
+
+If you need to use different credentials than dbt:
+
+```python
+from dbt_logger import DbtLogger, get_connection_params_from_env
+
+# Option 1: From environment variables
+connection_params = get_connection_params_from_env()
+
+# Option 2: Manual dict
+connection_params = {
+    'account': 'your_account',
+    'user': 'your_user',
+    'password': 'your_password',
+    'database': 'your_database',
+    'warehouse': 'your_warehouse',
+}
+
+logger = DbtLogger(
+    repo_name="my_project",
+    connection_params=connection_params
+)
+```
+
+## How It Works
+
+1. **Reads your dbt profiles.yml** - Automatically finds and parses your dbt configuration
+2. **Supports private key auth** - Works with your existing DBT_USER, DBT_PVK_PATH, DBT_PVK_PASS env vars
+3. **Creates logging infrastructure** - Auto-creates schema and table on first run
+4. **Captures everything** - Runs dbt commands and logs all output in real-time
+5. **Stores in Snowflake** - Saves command history for auditing and monitoring
+
+## Logging Table Schema
+
+```sql
+-- Default location: [your_dbt_database].logging.dbt_logging
+CREATE TABLE dbt_logging (
+    repo_name STRING,      -- Your dbt project/repo name
+    command STRING,        -- The dbt command executed
+    stdout_log STRING,     -- Complete command output
+    log_time TIMESTAMP_LTZ -- Execution timestamp
+);
+```
+
+## dbt profiles.yml Locations
+
+The logger checks for profiles.yml in this order:
+1. `$DBT_PROFILES_DIR/profiles.yml`
+2. `./dbt/profiles/profiles.yml` (current directory)
+3. `~/.dbt/profiles.yml` (default dbt location)
+
+## Features
+
+- ✅ **Zero Config** - Uses your existing dbt credentials
+- ✅ **Private Key Auth** - Full support for private key authentication
+- ✅ **Auto Setup** - Creates schema and table automatically
+- ✅ **Real-time Output** - See command output live while logging
+- ✅ **Flexible Storage** - Default to dbt database or use separate logging database
+- ✅ **Environment Variables** - Resolves Jinja env_var() expressions from profiles.yml
+
+## License
+
+MIT License - see LICENSE file for details.

dbt_logger-0.1.1/dbt_logger/__init__.py

@@ -0,0 +1,7 @@
+"""dbt-logger: A logger for dbt projects"""
+
+from .logger import DbtLogger
+from .utils import get_connection_params_from_dbt, get_connection_params_from_env
+
+__version__ = "0.1.0"
+__all__ = ["DbtLogger", "get_connection_params_from_dbt", "get_connection_params_from_env"]

dbt_logger-0.1.1/dbt_logger/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running dbt-logger as a module: python -m dbt_logger"""
+
+from .cli import main
+
+if __name__ == '__main__':
+    main()

dbt_logger-0.1.1/dbt_logger/cli.py

@@ -0,0 +1,159 @@
+"""CLI interface for dbt-logger."""
+
+import argparse
+import sys
+from typing import Optional
+from .utils import get_connection_params_from_dbt, get_logger_config, get_dbt_profile_path
+from .logger import DbtLogger
+
+
+def show_config(repo_name: str, target: Optional[str] = None):
+    """Show the current configuration and where logs will be written."""
+    print("=" * 60)
+    print("dbt-logger Configuration")
+    print("=" * 60)
+    
+    try:
+        # Find profiles.yml
+        profiles_path = get_dbt_profile_path()
+        print(f"✓ profiles.yml: {profiles_path}")
+        
+        # Get connection params
+        connection_params = get_connection_params_from_dbt(target=target)
+        dbt_database = connection_params.get('database')
+        print(f"✓ dbt database: {dbt_database}")
+        print(f"✓ target: {target or 'default'}")
+        
+        # Get logger config
+        config = get_logger_config()
+        if config:
+            print(f"✓ Config file found with: {config}")
+        else:
+            print("  No dbt_logger.yml config file found (using defaults)")
+        
+        # Determine final logging location
+        database = config.get('database') or dbt_database
+        schema = config.get('schema') or "logging"
+        table_name = config.get('table_name') or "dbt_logging"
+        
+        print("\n" + "=" * 60)
+        print("Logs will be written to:")
+        print("=" * 60)
+        print(f"  Database:   {database}")
+        print(f"  Schema:     {schema}")
+        print(f"  Table:      {table_name}")
+        print(f"  Full path:  {database}.{schema}.{table_name}")
+        print("=" * 60)
+        
+    except Exception as e:
+        print(f"✗ Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def test_connection(repo_name: str, target: Optional[str] = None):
+    """Test the Snowflake connection."""
+    print("=" * 60)
+    print("Testing Snowflake Connection")
+    print("=" * 60)
+    
+    try:
+        connection_params = get_connection_params_from_dbt(target=target)
+        print(f"✓ Loaded credentials for target: {target or 'default'}")
+        
+        # Try to create logger (this will test connection)
+        logger = DbtLogger(repo_name=repo_name, target=target)
+        print(f"✓ Connected to Snowflake")
+        print(f"✓ Verified/created: {logger.full_table_name}")
+        print("\n" + "=" * 60)
+        print("Connection test PASSED ✓")
+        print("=" * 60)
+        
+    except Exception as e:
+        print(f"\n✗ Connection test FAILED", file=sys.stderr)
+        print(f"✗ Error: {e}", file=sys.stderr)
+        print("=" * 60)
+        sys.exit(1)
+
+
+def run_test_command(repo_name: str, target: Optional[str] = None):
+    """Run a test dbt command and log it."""
+    print("=" * 60)
+    print("Running Test Command")
+    print("=" * 60)
+    
+    try:
+        logger = DbtLogger(repo_name=repo_name, target=target)
+        print(f"Logging to: {logger.full_table_name}\n")
+        
+        # Run a simple dbt command
+        exit_code = logger.run_command("dbt --version")
+        
+        if exit_code == 0:
+            print("\n" + "=" * 60)
+            print("Test PASSED ✓")
+            print(f"Check {logger.full_table_name} for the logged output")
+            print("=" * 60)
+        else:
+            print(f"\nCommand exited with code: {exit_code}")
+            
+    except Exception as e:
+        print(f"✗ Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog='dbt-logger',
+        description='Test and configure dbt-logger'
+    )
+    
+    parser.add_argument(
+        '--show-config',
+        action='store_true',
+        help='Show where logs will be written'
+    )
+    
+    parser.add_argument(
+        '--test-connection',
+        action='store_true',
+        help='Test the Snowflake connection'
+    )
+    
+    parser.add_argument(
+        '--test-run',
+        action='store_true',
+        help='Run a test command (dbt --version) and log it'
+    )
+    
+    parser.add_argument(
+        '--repo-name',
+        default='test_repo',
+        help='Repository name for testing (default: test_repo)'
+    )
+    
+    parser.add_argument(
+        '--target',
+        help='dbt target to use (e.g., dev, prod)'
+    )
+    
+    args = parser.parse_args()
+    
+    # If no action specified, show help
+    if not any([args.show_config, args.test_connection, args.test_run]):
+        parser.print_help()
+        sys.exit(0)
+    
+    # Run requested actions
+    if args.show_config:
+        show_config(args.repo_name, args.target)
+    
+    if args.test_connection:
+        test_connection(args.repo_name, args.target)
+    
+    if args.test_run:
+        run_test_command(args.repo_name, args.target)
+
+
+if __name__ == '__main__':
+    main()

dbt_logger-0.1.1/dbt_logger/logger.py

@@ -0,0 +1,161 @@
+"""Main logger implementation for dbt projects."""
+
+import subprocess
+import sys
+from datetime import datetime
+from typing import Optional, Dict, Any
+import snowflake.connector
+from .utils import get_connection_params_from_dbt, get_logger_config
+
+
+class DbtLogger:
+    """A logger that captures dbt command output and logs to Snowflake."""
+    
+    def __init__(
+        self,
+        repo_name: str,
+        connection_params: Optional[Dict[str, Any]] = None,
+        profile_name: Optional[str] = None,
+        target: Optional[str] = None,
+        table_name: Optional[str] = None,
+        schema: Optional[str] = None,
+        database: Optional[str] = None
+    ):
+        """
+        Initialize the DbtLogger.
+        
+        Args:
+            repo_name: Name of the dbt project/repo
+            connection_params: Snowflake connection parameters (if None, reads from dbt profiles.yml)
+            profile_name: dbt profile name (only used if connection_params is None)
+            target: dbt target name like 'dev' or 'prod' (only used if connection_params is None)
+            table_name: Name of the logging table (overrides config file)
+            schema: Schema name (overrides config file)
+            database: Database name (overrides config file)
+        """
+        self.repo_name = repo_name
+        
+        # Get connection params from dbt profiles if not provided
+        if connection_params is None:
+            connection_params = get_connection_params_from_dbt(
+                profile_name=profile_name,
+                target=target
+            )
+        
+        self.connection_params = connection_params
+        
+        # Load config file settings
+        config = get_logger_config()
+        
+        # Determine database, schema, and table name with precedence:
+        # 1. Explicit parameter
+        # 2. Config file
+        # 3. Defaults
+        dbt_database = connection_params.get('database')
+        
+        self.database = database or config.get('database') or dbt_database
+        self.schema = schema or config.get('schema') or "logging"
+        self.table_name = table_name or config.get('table_name') or "dbt_logging"
+        
+        self.full_table_name = f"{self.database}.{self.schema}.{self.table_name}"
+        
+        # Ensure the logging table exists
+        self._ensure_table_exists()
+    
+    def _get_connection(self):
+        """Get a Snowflake connection."""
+        return snowflake.connector.connect(**self.connection_params)
+    
+    def _ensure_table_exists(self):
+        """Create the logging schema and table if they don't exist."""
+        create_schema_sql = f"CREATE SCHEMA IF NOT EXISTS {self.database}.{self.schema}"
+        
+        create_table_sql = f"""
+        CREATE TABLE IF NOT EXISTS {self.full_table_name} (
+            repo_name STRING,
+            command STRING,
+            stdout_log STRING,
+            log_time TIMESTAMP_LTZ DEFAULT CURRENT_TIMESTAMP()
+        )
+        """
+        
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+            cursor.execute(create_schema_sql)
+            cursor.execute(create_table_sql)
+            cursor.close()
+            conn.close()
+        except Exception as e:
+            print(f"Warning: Could not create logging table: {e}")
+    
+    def run_command(self, command: str) -> int:
+        """
+        Run a dbt command and log its output to Snowflake.
+        
+        Args:
+            command: The full dbt command to run (e.g., "dbt build", "dbt run --select model_name")
+        
+        Returns:
+            Exit code of the command
+        """
+        print(f"Running: {command}")
+        print("=" * 60)
+        
+        # Run the command and capture output
+        try:
+            process = subprocess.Popen(
+                command,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            output_lines = []
+            for line in process.stdout:
+                # Print in real-time
+                print(line, end='')
+                output_lines.append(line)
+            
+            process.wait()
+            exit_code = process.returncode
+            
+            # Combine all output
+            full_output = ''.join(output_lines)
+            
+            # Log to Snowflake
+            self._log_to_snowflake(command, full_output)
+            
+            print("=" * 60)
+            print(f"Command completed with exit code: {exit_code}")
+            
+            return exit_code
+            
+        except Exception as e:
+            error_msg = f"Error running command: {e}"
+            print(error_msg)
+            self._log_to_snowflake(command, error_msg)
+            return 1
+    
+    def _log_to_snowflake(self, command: str, stdout_log: str):
+        """Insert the command and output into Snowflake."""
+        insert_sql = f"""
+        INSERT INTO {self.full_table_name} (repo_name, command, stdout_log, log_time)
+        VALUES (%s, %s, %s, %s)
+        """
+        
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+            cursor.execute(
+                insert_sql,
+                (self.repo_name, command, stdout_log, datetime.now())
+            )
+            conn.commit()
+            cursor.close()
+            conn.close()
+        except Exception as e:
+            print(f"Warning: Could not log to Snowflake: {e}")

dbt_logger-0.1.1/dbt_logger/utils.py

@@ -0,0 +1,234 @@
+"""Utility functions for dbt-logger."""
+
+from typing import Dict, Any, Optional
+import os
+import yaml
+import re
+from pathlib import Path
+
+
+def get_logger_config() -> Dict[str, Any]:
+    """
+    Load configuration from dbt/dbt_logger.yml if it exists.
+    
+    Returns:
+        Dictionary with optional keys: database, schema, table_name
+    """
+    config_paths = [
+        Path.cwd() / 'dbt' / 'dbt_logger.yml',
+        Path.cwd() / 'dbt_logger.yml',
+    ]
+
+    # Also check next to profiles.yml if found
+    try:
+        from .utils import get_dbt_profile_path
+        profiles_path = get_dbt_profile_path()
+        profiles_dir = profiles_path.parent.parent if profiles_path.name == 'profiles.yml' and profiles_path.parent.name == 'profiles' else profiles_path.parent
+        config_paths.append(profiles_dir / 'dbt_logger.yml')
+    except Exception:
+        pass
+
+    for config_path in config_paths:
+        if config_path.exists():
+            with open(config_path, 'r') as f:
+                config = yaml.safe_load(f) or {}
+                return config
+
+    return {}
+
+
+def _resolve_env_var(value: str) -> str:
+    """
+    Resolve Jinja-style environment variable references.
+    
+    Handles patterns like {{ env_var('VAR_NAME') }}
+    """
+    if not isinstance(value, str):
+        return value
+    
+    # Match {{ env_var('VAR_NAME') }} or {{ env_var("VAR_NAME") }}
+    pattern = r"{{\s*env_var\(['\"]([^'\"]+)['\"]\)\s*}}"
+    
+    def replacer(match):
+        env_var_name = match.group(1)
+        env_value = os.getenv(env_var_name)
+        if env_value is None:
+            raise ValueError(f"Environment variable '{env_var_name}' is not set")
+        return env_value
+    
+    return re.sub(pattern, replacer, value)
+
+
+def get_dbt_profile_path() -> Path:
+    """
+    Get the path to the dbt profiles.yml file.
+    
+    Checks in order:
+    1. DBT_PROFILES_DIR environment variable
+    2. Current directory ./dbt/profiles/profiles.yml
+    3. ~/.dbt/profiles.yml (default location)
+    """
+    # Check environment variable
+    profiles_dir = os.getenv('DBT_PROFILES_DIR')
+    if profiles_dir:
+        profiles_path = Path(profiles_dir) / 'profiles.yml'
+        if profiles_path.exists():
+            return profiles_path
+    
+    # Check local dbt/profiles directory
+    local_path = Path.cwd() / 'dbt' / 'profiles' / 'profiles.yml'
+    if local_path.exists():
+        return local_path
+    
+    # Check default home directory
+    home_path = Path.home() / '.dbt' / 'profiles.yml'
+    if home_path.exists():
+        return home_path
+    
+    raise FileNotFoundError(
+        "Could not find profiles.yml. Checked:\n"
+        f"  - $DBT_PROFILES_DIR/profiles.yml\n"
+        f"  - {local_path}\n"
+        f"  - {home_path}"
+    )
+
+
+def get_connection_params_from_dbt(
+    profile_name: Optional[str] = None,
+    target: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Get Snowflake connection parameters from dbt profiles.yml.
+    
+    Args:
+        profile_name: Name of the profile in profiles.yml (if None, uses DBT_PROFILE env var or first profile)
+        target: Target name (dev/prod) (if None, uses profile's default target)
+    
+    Returns:
+        Dictionary of connection parameters suitable for snowflake.connector.connect()
+    """
+    profiles_path = get_dbt_profile_path()
+    
+    with open(profiles_path, 'r') as f:
+        profiles = yaml.safe_load(f)
+    
+    # Determine which profile to use
+    if profile_name is None:
+        profile_name = os.getenv('DBT_PROFILE')
+    
+    if profile_name is None:
+        # Use the first profile (excluding 'config' key if present)
+        available_profiles = [k for k in profiles.keys() if k != 'config']
+        if not available_profiles:
+            raise ValueError("No profiles found in profiles.yml")
+        profile_name = available_profiles[0]
+    
+    if profile_name not in profiles:
+        raise ValueError(f"Profile '{profile_name}' not found in profiles.yml")
+    
+    profile = profiles[profile_name]
+    
+    # Determine which target to use
+    if target is None:
+        target = profile.get('target')
+    
+    if target is None:
+        raise ValueError(f"No target specified and profile '{profile_name}' has no default target")
+    
+    if target not in profile.get('outputs', {}):
+        raise ValueError(f"Target '{target}' not found in profile '{profile_name}'")
+    
+    output = profile['outputs'][target]
+    
+    # Resolve environment variables in the output
+    resolved_output = {}
+    for key, value in output.items():
+        if isinstance(value, str):
+            resolved_output[key] = _resolve_env_var(value)
+        else:
+            resolved_output[key] = value
+    
+    # Build connection parameters for Snowflake
+    params = {
+        'account': resolved_output.get('account'),
+        'user': resolved_output.get('user'),
+        'warehouse': resolved_output.get('warehouse'),
+        'database': resolved_output.get('database'),
+    }
+    
+    # Handle authentication - private key or password
+    if 'private_key_path' in resolved_output:
+        # Private key authentication
+        private_key_path = resolved_output['private_key_path']
+        private_key_passphrase = resolved_output.get('private_key_passphrase')
+        
+        # Read and parse the private key
+        from cryptography.hazmat.backends import default_backend
+        from cryptography.hazmat.primitives import serialization
+        
+        with open(private_key_path, 'rb') as key_file:
+            private_key_data = key_file.read()
+        
+        passphrase = private_key_passphrase.encode() if private_key_passphrase else None
+        
+        private_key = serialization.load_pem_private_key(
+            private_key_data,
+            password=passphrase,
+            backend=default_backend()
+        )
+        
+        pkb = private_key.private_bytes(
+            encoding=serialization.Encoding.DER,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption()
+        )
+        
+        params['private_key'] = pkb
+    elif 'password' in resolved_output:
+        params['password'] = resolved_output['password']
+    else:
+        raise ValueError("No authentication method found (private_key_path or password)")
+    
+    # Optional parameters
+    if 'role' in resolved_output:
+        params['role'] = resolved_output['role']
+    
+    if 'schema' in resolved_output:
+        params['schema'] = resolved_output['schema']
+    
+    return params
+
+
+def get_connection_params_from_env() -> Dict[str, Any]:
+    """
+    Get Snowflake connection parameters from environment variables.
+    
+    Expected environment variables:
+    - SNOWFLAKE_ACCOUNT
+    - SNOWFLAKE_USER
+    - SNOWFLAKE_PASSWORD
+    - SNOWFLAKE_DATABASE
+    - SNOWFLAKE_WAREHOUSE
+    - SNOWFLAKE_ROLE (optional)
+    
+    Returns:
+        Dictionary of connection parameters
+    """
+    params = {
+        'account': os.getenv('SNOWFLAKE_ACCOUNT'),
+        'user': os.getenv('SNOWFLAKE_USER'),
+        'password': os.getenv('SNOWFLAKE_PASSWORD'),
+        'database': os.getenv('SNOWFLAKE_DATABASE'),
+        'warehouse': os.getenv('SNOWFLAKE_WAREHOUSE'),
+    }
+    
+    role = os.getenv('SNOWFLAKE_ROLE')
+    if role:
+        params['role'] = role
+    
+    # Validate required parameters
+    missing = [k for k, v in params.items() if v is None and k != 'role']
+    if missing:
+        raise ValueError(f"Missing required environment variables: {', '.join(f'SNOWFLAKE_{k.upper()}' for k in missing)}")
+    
+    return params

dbt_logger-0.1.1/pyproject.toml

@@ -0,0 +1,41 @@
+[tool.poetry]
+name = "dbt-logger"
+version = "0.1.1"
+description = "A lightweight logging utility for dbt projects"
+authors = ["Tristan Schwartz"]
+readme = "README.md"
+license = "MIT"
+homepage = "https://github.com/TristanSchwartz/dbt-logger"
+repository = "https://github.com/TristanSchwartz/dbt-logger"
+keywords = ["dbt", "logging", "data", "analytics"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+
+[tool.poetry.scripts]
+dbt-logger = "dbt_logger.cli:main"
+
+[tool.poetry.dependencies]
+python = "^3.9.2,<3.13"
+snowflake-connector-python = "^3.0.0"
+pyyaml = "^6.0.0"
+cryptography = "^41.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.0.0"
+pre-commit = "^3.3.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "primary"