/

Environment Variables

Environment Variables

Configure ByteHide Logs entirely through environment variables for seamless deployment across Docker, Kubernetes, and cloud platforms.

Core Variables

PROJECT_TOKEN

Your ByteHide project token - first checked by the SDK:

Bash
export PROJECT_TOKEN="bh_your_token_here"

Usage in Python:

Python
import os
from bytehide_logs import Log

# Automatically loaded if set
token = os.getenv("PROJECT_TOKEN")
if token:
    Log.set_project_token(token)

BYTEHIDE_PROJECT_TOKEN

Alternative environment variable for project token:

Bash
export BYTEHIDE_PROJECT_TOKEN="bh_your_token_here"

The SDK checks variables in order:

  1. PROJECT_TOKEN
  2. BYTEHIDE_PROJECT_TOKEN

Logging Configuration

BYTEHIDE_CONSOLE_ENABLED

Enable console output:

Bash
export BYTEHIDE_CONSOLE_ENABLED=true
export BYTEHIDE_CONSOLE_ENABLED=false

BYTEHIDE_LOG_LEVEL

Set minimum log level (TRACE, DEBUG, INFO, WARN, ERROR, CRITICAL):

Bash
export BYTEHIDE_LOG_LEVEL=INFO
export BYTEHIDE_LOG_LEVEL=DEBUG
export BYTEHIDE_LOG_LEVEL=WARN

BYTEHIDE_FILE_PATH

Path to log file:

Bash
export BYTEHIDE_FILE_PATH=/var/log/myapp/app.log
export BYTEHIDE_FILE_PATH=./logs/app.log

BYTEHIDE_PERSIST

Enable file persistence:

Bash
export BYTEHIDE_PERSIST=true
export BYTEHIDE_PERSIST=false

BYTEHIDE_ROLLING_INTERVAL

Log file rotation interval (MINUTE, HOUR, DAY, WEEK, MONTH, YEAR):

Bash
export BYTEHIDE_ROLLING_INTERVAL=DAY
export BYTEHIDE_ROLLING_INTERVAL=HOUR

BYTEHIDE_FILE_SIZE_LIMIT

Maximum file size in bytes before rotation:

Bash
# 10MB
export BYTEHIDE_FILE_SIZE_LIMIT=10485760

# 50MB
export BYTEHIDE_FILE_SIZE_LIMIT=52428800

# 100MB
export BYTEHIDE_FILE_SIZE_LIMIT=104857600

BYTEHIDE_ROLL_ON_SIZE

Enable size-based rotation:

Bash
export BYTEHIDE_ROLL_ON_SIZE=true
export BYTEHIDE_ROLL_ON_SIZE=false

BYTEHIDE_INCLUDE_CALLER_INFO

Include filename and line number in logs:

Bash
export BYTEHIDE_INCLUDE_CALLER_INFO=true

BYTEHIDE_SENSITIVE_DATA

Comma-separated list of keywords to mask:

Bash
export BYTEHIDE_SENSITIVE_DATA="password,token,api_key,secret"

Docker Configuration

Basic Docker Usage

DOCKERFILE
FROM python:3.9
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENV PROJECT_TOKEN=bh_your_token
CMD ["python", "app.py"]

Build and run:

Bash
docker build -t myapp .
docker run -e PROJECT_TOKEN="bh_token" myapp

Docker Compose

YAML
version: '3.8'
services:
  app:
    build: .
    environment:
      - PROJECT_TOKEN=${PROJECT_TOKEN}
      - BYTEHIDE_CONSOLE_ENABLED=true
      - BYTEHIDE_LOG_LEVEL=INFO
      - BYTEHIDE_PERSIST=true
      - BYTEHIDE_FILE_PATH=/var/log/myapp/app.log
    volumes:
      - ./logs:/var/log/myapp

Run with:

Bash
PROJECT_TOKEN="bh_token" docker-compose up

Docker with .env File

Create .env file:

CODE
PROJECT_TOKEN=bh_your_token
BYTEHIDE_CONSOLE_ENABLED=true
BYTEHIDE_LOG_LEVEL=DEBUG
BYTEHIDE_PERSIST=true
BYTEHIDE_FILE_PATH=/var/log/myapp/app.log

Docker Compose will automatically load it:

Bash
docker-compose up

Kubernetes Configuration

Basic Deployment with Env Vars

YAML
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        env:
        - name: PROJECT_TOKEN
          value: "bh_your_token"
        - name: BYTEHIDE_CONSOLE_ENABLED
          value: "true"
        - name: BYTEHIDE_LOG_LEVEL
          value: "INFO"
        - name: BYTEHIDE_PERSIST
          value: "true"
        - name: BYTEHIDE_FILE_PATH
          value: "/var/log/myapp/app.log"

Using Kubernetes Secrets

Create secret:

Bash
kubectl create secret generic bytehide-secret --from-literal=project-token=bh_your_token

Reference in deployment:

YAML
env:
- name: PROJECT_TOKEN
  valueFrom:
    secretKeyRef:
      name: bytehide-secret
      key: project-token

ConfigMap for Settings

Create ConfigMap:

YAML
apiVersion: v1
kind: ConfigMap
metadata:
  name: bytehide-config
data:
  BYTEHIDE_CONSOLE_ENABLED: "true"
  BYTEHIDE_LOG_LEVEL: "INFO"
  BYTEHIDE_PERSIST: "true"
  BYTEHIDE_ROLLING_INTERVAL: "DAY"

Use in Deployment:

YAML
envFrom:
- configMapRef:
    name: bytehide-config
env:
- name: PROJECT_TOKEN
  valueFrom:
    secretKeyRef:
      name: bytehide-secret
      key: project-token

Cloud Platform Configuration

AWS Lambda

Python
import os
from bytehide_logs import Log, LogSettings, LogLevel

def lambda_handler(event, context):
    # Load configuration from environment
    token = os.getenv("PROJECT_TOKEN")
    console = os.getenv("BYTEHIDE_CONSOLE_ENABLED", "true") == "true"
    level = os.getenv("BYTEHIDE_LOG_LEVEL", "INFO")
    
    Log.set_project_token(token)
    Log.initialize(LogSettings(
        console_enabled=console,
        minimum_level=LogLevel[level]
    ))
    
    Log.info("Lambda function invoked")
    return {"statusCode": 200}

Google Cloud Run

Bash
gcloud run deploy myapp \
  --set-env-vars PROJECT_TOKEN=bh_your_token \
  --set-env-vars BYTEHIDE_CONSOLE_ENABLED=true \
  --set-env-vars BYTEHIDE_LOG_LEVEL=INFO

Azure Container Instances

Bash
az container create \
  --resource-group mygroup \
  --name myapp \
  --image myapp:latest \
  --environment-variables PROJECT_TOKEN=bh_token BYTEHIDE_CONSOLE_ENABLED=true

Local Development Setup

Using .env File

Create .env:

Bash
PROJECT_TOKEN=bh_dev_token
BYTEHIDE_CONSOLE_ENABLED=true
BYTEHIDE_LOG_LEVEL=DEBUG
BYTEHIDE_PERSIST=true
BYTEHIDE_FILE_PATH=./logs/app.log
BYTEHIDE_INCLUDE_CALLER_INFO=true

Load in your application:

Python
import os
from dotenv import load_dotenv

load_dotenv()  # Load from .env

from bytehide_logs import Log, LogSettings, LogLevel

# Configuration automatically loaded
Log.set_project_token(os.getenv("PROJECT_TOKEN"))

console = os.getenv("BYTEHIDE_CONSOLE_ENABLED", "true") == "true"
level = os.getenv("BYTEHIDE_LOG_LEVEL", "INFO")

Log.initialize(LogSettings(
    console_enabled=console,
    minimum_level=LogLevel[level]
))

Environment-Based Configuration

Development

Bash
export ENV=development
export PROJECT_TOKEN=bh_dev_token
export BYTEHIDE_CONSOLE_ENABLED=true
export BYTEHIDE_LOG_LEVEL=DEBUG
export BYTEHIDE_PERSIST=true
export BYTEHIDE_INCLUDE_CALLER_INFO=true

Staging

Bash
export ENV=staging
export PROJECT_TOKEN=bh_staging_token
export BYTEHIDE_CONSOLE_ENABLED=true
export BYTEHIDE_LOG_LEVEL=INFO
export BYTEHIDE_PERSIST=true
export BYTEHIDE_FILE_PATH=/var/log/myapp/app.log

Production

Bash
export ENV=production
export PROJECT_TOKEN=bh_prod_token
export BYTEHIDE_CONSOLE_ENABLED=false
export BYTEHIDE_LOG_LEVEL=WARN
export BYTEHIDE_PERSIST=true
export BYTEHIDE_FILE_PATH=/var/log/myapp/app.log
export BYTEHIDE_ROLLING_INTERVAL=DAY
export BYTEHIDE_ROLL_ON_SIZE=true
export BYTEHIDE_FILE_SIZE_LIMIT=52428800
export BYTEHIDE_SENSITIVE_DATA="password,token,api_key,secret"

Python Helper for Env Config

Python
import os
from bytehide_logs import Log, LogSettings, LogLevel, RollingInterval

def setup_from_env():
    """Initialize ByteHide Logs from environment variables"""
    
    # Token
    token = os.getenv("PROJECT_TOKEN") or os.getenv("BYTEHIDE_PROJECT_TOKEN")
    if not token:
        raise ValueError("PROJECT_TOKEN not set")
    Log.set_project_token(token)
    
    # Convert string env vars to appropriate types
    console = os.getenv("BYTEHIDE_CONSOLE_ENABLED", "true").lower() == "true"
    persist = os.getenv("BYTEHIDE_PERSIST", "false").lower() == "true"
    caller_info = os.getenv("BYTEHIDE_INCLUDE_CALLER_INFO", "false").lower() == "true"
    roll_on_size = os.getenv("BYTEHIDE_ROLL_ON_SIZE", "false").lower() == "true"
    
    level_str = os.getenv("BYTEHIDE_LOG_LEVEL", "INFO")
    minimum_level = LogLevel[level_str]
    
    interval_str = os.getenv("BYTEHIDE_ROLLING_INTERVAL", "DAY")
    rolling_interval = RollingInterval[interval_str]
    
    file_size = int(os.getenv("BYTEHIDE_FILE_SIZE_LIMIT", "104857600"))
    
    mask_str = os.getenv("BYTEHIDE_SENSITIVE_DATA", "")
    mask_list = [m.strip() for m in mask_str.split(",") if m.strip()]
    
    settings = LogSettings(
        console_enabled=console,
        minimum_level=minimum_level,
        include_caller_info=caller_info,
        persist=persist,
        file_path=os.getenv("BYTEHIDE_FILE_PATH"),
        rolling_interval=rolling_interval,
        roll_on_file_size_limit=roll_on_size,
        file_size_limit_bytes=file_size,
        mask_sensitive_data=mask_list
    )
    
    Log.initialize(settings)

if __name__ == "__main__":
    setup_from_env()
    Log.info("Logging configured from environment")

Verifying Environment Variables

Bash
# Check if variables are set
echo $PROJECT_TOKEN
echo $BYTEHIDE_CONSOLE_ENABLED
echo $BYTEHIDE_LOG_LEVEL

# In Python
import os
print(f"PROJECT_TOKEN: {os.getenv('PROJECT_TOKEN')}")
print(f"BYTEHIDE_CONSOLE_ENABLED: {os.getenv('BYTEHIDE_CONSOLE_ENABLED')}")

Troubleshooting

Variables Not Being Read

Ensure variables are exported:

Bash
# Not set
BYTEHIDE_CONSOLE_ENABLED=true python app.py

# Properly exported
export BYTEHIDE_CONSOLE_ENABLED=true
python app.py

Case Sensitivity

Environment variable names are case-sensitive. Use uppercase:

Bash
# Correct
export BYTEHIDE_LOG_LEVEL=INFO

# Incorrect - won't work
export bytehide_log_level=INFO

Next Steps

Previous
File Logging
Next
Disable Logging