Clean up langfuse docs and scripts (#4220)

CONTRIBUTING.md

@@ -100,10 +100,12 @@ To fork the repository:
 1. Go to https://github.com/block/goose and click “Fork” (top-right corner).
 2. This creates https://github.com/<your-username>/goose under your GitHub account.
 3. Clone your fork (not the main repo):
+
 ```
 git clone https://github.com/<your-username>/goose.git
 cd goose
 ```
+
 4. Add the main repository as upstream:
 
 ```
@@ -115,6 +117,7 @@ git remote add upstream https://github.com/block/goose.git
 ```
 git checkout -b my-feature-branch
 ```
+
 6. Sync your fork with the main repo:
 
 ```
@@ -126,6 +129,7 @@ git merge upstream/main
 ```
 
 7. Push to your fork. Because you’re the owner of the fork, you have permission to push here.
+
 ```
 git push origin my-feature-branch
 ```
@@ -140,36 +144,35 @@ To ensure a smooth integration of your contributions, it's important that your f
 
 1. **Add the Main Repository as a Remote** (Skip if you have already set this up):
 
-    ```bash
+   ```bash
-    git remote add upstream https://github.com/block/goose.git
+   git remote add upstream https://github.com/block/goose.git
-    ```
+   ```
 
 2. **Fetch the Latest Changes from the Main Repository**:
 
-    ```bash
+   ```bash
-    git fetch upstream
+   git fetch upstream
-    ```
+   ```
 
 3. **Checkout Your Development Branch**:
 
-    ```bash
+   ```bash
-    git checkout your-branch-name
+   git checkout your-branch-name
-    ```
+   ```
 
 4. **Merge Changes from the Main Branch into Your Branch**:
 
-    ```bash
+   ```bash
-    git merge upstream/main
+   git merge upstream/main
-    ```
+   ```
 
-    Resolve any conflicts that arise and commit the changes.
+   Resolve any conflicts that arise and commit the changes.
 
 5. **Push the Merged Changes to Your Fork**:
 
-    ```bash
+   ```bash
-    git push origin your-branch-name
+   git push origin your-branch-name
-    ```
+   ```
-    
 
 This process will help you keep your branch aligned with the ongoing changes in the main repository, minimizing integration issues when it comes time to merge!
 
@@ -197,9 +200,8 @@ or `DATABRICKS_HOST`. Refer to the provider details for more info on required ke
 
 ## Enable traces in Goose with [locally hosted Langfuse](https://langfuse.com/docs/deployment/self-host)
 
-- Run `just langfuse-server` to start your local Langfuse server. It requires Docker.
+- Start a local Langfuse using the docs [here](https://langfuse.com/self-hosting/docker-compose). Create an organization and project and create API credentials.
-- Go to http://localhost:3000 and log in with the default email/password output by the shell script (values can also be found in the `.env.langfuse.local` file).
+- Set the environment variables so that Goose can connect to the langfuse server:
-- Set the environment variables so that rust can connect to the langfuse server
 
 ```
 export LANGFUSE_INIT_PROJECT_PUBLIC_KEY=publickey-local

scripts/.env.langfuse.local

@@ -1,11 +0,0 @@
-# These variables are default initialization variables for locally hosted Langfuse server
-LANGFUSE_INIT_PROJECT_NAME=goose-local
-LANGFUSE_INIT_PROJECT_PUBLIC_KEY=publickey-local
-LANGFUSE_INIT_PROJECT_SECRET_KEY=secretkey-local
-LANGFUSE_INIT_USER_EMAIL=local@block.xyz
-LANGFUSE_INIT_USER_NAME=localdev
-LANGFUSE_INIT_USER_PASSWORD=localpwd
-
-LANGFUSE_INIT_ORG_ID=local-id
-LANGFUSE_INIT_ORG_NAME=local-org
-LANGFUSE_INIT_PROJECT_ID=goose

scripts/langfuse-docker-compose.yaml

@@ -1,152 +0,0 @@
-services:
-  langfuse-worker:
-    image: langfuse/langfuse-worker:3
-    restart: always
-    depends_on: &langfuse-depends-on
-      postgres:
-        condition: service_healthy
-      minio:
-        condition: service_healthy
-      redis:
-        condition: service_healthy
-      clickhouse:
-        condition: service_healthy
-    ports:
-      - "3030:3030"
-    environment: &langfuse-worker-env
-      DATABASE_URL: postgresql://postgres:postgres@postgres:5432/postgres
-      SALT: "mysalt"
-      ENCRYPTION_KEY: "0000000000000000000000000000000000000000000000000000000000000000" # generate via `openssl rand -hex 32`
-      TELEMETRY_ENABLED: ${TELEMETRY_ENABLED:-true}
-      LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES: ${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-true}
-      CLICKHOUSE_MIGRATION_URL: ${CLICKHOUSE_MIGRATION_URL:-clickhouse://clickhouse:9000}
-      CLICKHOUSE_URL: ${CLICKHOUSE_URL:-http://clickhouse:8123}
-      CLICKHOUSE_USER: ${CLICKHOUSE_USER:-clickhouse}
-      CLICKHOUSE_PASSWORD: ${CLICKHOUSE_PASSWORD:-clickhouse}
-      CLICKHOUSE_CLUSTER_ENABLED: ${CLICKHOUSE_CLUSTER_ENABLED:-false}
-      LANGFUSE_S3_EVENT_UPLOAD_BUCKET: ${LANGFUSE_S3_EVENT_UPLOAD_BUCKET:-langfuse}
-      LANGFUSE_S3_EVENT_UPLOAD_REGION: ${LANGFUSE_S3_EVENT_UPLOAD_REGION:-auto}
-      LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID: ${LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID:-minio}
-      LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY: ${LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY:-miniosecret}
-      LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT: ${LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT:-http://minio:9000}
-      LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE: ${LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE:-true}
-      LANGFUSE_S3_EVENT_UPLOAD_PREFIX: ${LANGFUSE_S3_EVENT_UPLOAD_PREFIX:-events/}
-      LANGFUSE_S3_MEDIA_UPLOAD_BUCKET: ${LANGFUSE_S3_MEDIA_UPLOAD_BUCKET:-langfuse}
-      LANGFUSE_S3_MEDIA_UPLOAD_REGION: ${LANGFUSE_S3_MEDIA_UPLOAD_REGION:-auto}
-      LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID: ${LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID:-minio}
-      LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY: ${LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY:-miniosecret}
-      LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT: ${LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT:-http://minio:9000}
-      LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE: ${LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE:-true}
-      LANGFUSE_S3_MEDIA_UPLOAD_PREFIX: ${LANGFUSE_S3_MEDIA_UPLOAD_PREFIX:-media/}
-      REDIS_HOST: ${REDIS_HOST:-redis}
-      REDIS_PORT: ${REDIS_PORT:-6379}
-      REDIS_AUTH: ${REDIS_AUTH:-myredissecret}
-
-  langfuse-web:
-    image: langfuse/langfuse:3
-    restart: always
-    depends_on: *langfuse-depends-on
-    ports:
-      - "3000:3000"
-    environment:
-      <<: *langfuse-worker-env
-      NEXTAUTH_URL: http://localhost:3000
-      NEXTAUTH_SECRET: mysecret
-      LANGFUSE_INIT_ORG_ID: ${LANGFUSE_INIT_ORG_ID:-}
-      LANGFUSE_INIT_ORG_NAME: ${LANGFUSE_INIT_ORG_NAME:-}
-      LANGFUSE_INIT_PROJECT_ID: ${LANGFUSE_INIT_PROJECT_ID:-}
-      LANGFUSE_INIT_PROJECT_NAME: ${LANGFUSE_INIT_PROJECT_NAME:-}
-      LANGFUSE_INIT_PROJECT_PUBLIC_KEY: ${LANGFUSE_INIT_PROJECT_PUBLIC_KEY:-}
-      LANGFUSE_INIT_PROJECT_SECRET_KEY: ${LANGFUSE_INIT_PROJECT_SECRET_KEY:-}
-      LANGFUSE_INIT_USER_EMAIL: ${LANGFUSE_INIT_USER_EMAIL:-}
-      LANGFUSE_INIT_USER_NAME: ${LANGFUSE_INIT_USER_NAME:-}
-      LANGFUSE_INIT_USER_PASSWORD: ${LANGFUSE_INIT_USER_PASSWORD:-}
-      LANGFUSE_SDK_CI_SYNC_PROCESSING_ENABLED: ${LANGFUSE_SDK_CI_SYNC_PROCESSING_ENABLED:-false}
-      LANGFUSE_READ_FROM_POSTGRES_ONLY: ${LANGFUSE_READ_FROM_POSTGRES_ONLY:-false}
-      LANGFUSE_READ_FROM_CLICKHOUSE_ONLY: ${LANGFUSE_READ_FROM_CLICKHOUSE_ONLY:-true}
-      LANGFUSE_RETURN_FROM_CLICKHOUSE: ${LANGFUSE_RETURN_FROM_CLICKHOUSE:-true}
-
-  clickhouse:
-    image: clickhouse/clickhouse-server
-    restart: always
-    user: "101:101"
-    container_name: clickhouse
-    hostname: clickhouse
-    environment:
-      CLICKHOUSE_DB: default
-      CLICKHOUSE_USER: clickhouse
-      CLICKHOUSE_PASSWORD: clickhouse
-    volumes:
-      - langfuse_clickhouse_data:/var/lib/clickhouse
-      - langfuse_clickhouse_logs:/var/log/clickhouse-server
-    ports:
-      - "8123:8123"
-      - "9000:9000"
-    healthcheck:
-      test: wget --no-verbose --tries=1 --spider http://localhost:8123/ping || exit 1
-      interval: 5s
-      timeout: 5s
-      retries: 10
-      start_period: 1s
-
-  minio:
-    image: minio/minio
-    restart: always
-    container_name: minio
-    entrypoint: sh
-    # create the 'langfuse' bucket before starting the service
-    command: -c 'mkdir -p /data/langfuse && minio server --address ":9000" --console-address ":9001" /data'
-    environment:
-      MINIO_ROOT_USER: minio
-      MINIO_ROOT_PASSWORD: miniosecret
-    ports:
-      - "9090:9000"
-      - "9091:9001"
-    volumes:
-      - langfuse_minio_data:/data
-    healthcheck:
-      test: ["CMD", "mc", "ready", "local"]
-      interval: 1s
-      timeout: 5s
-      retries: 5
-      start_period: 1s
-
-  redis:
-    image: redis:7
-    restart: always
-    command: >
-      --requirepass ${REDIS_AUTH:-myredissecret}
-    ports:
-      - 6379:6379
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 3s
-      timeout: 10s
-      retries: 10
-
-  postgres:
-    image: postgres:${POSTGRES_VERSION:-latest}
-    restart: always
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
-      interval: 3s
-      timeout: 3s
-      retries: 10
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: postgres
-    ports:
-      - 5432:5432
-    volumes:
-      - langfuse_postgres_data:/var/lib/postgresql/data
-
-volumes:
-  langfuse_postgres_data:
-    driver: local
-  langfuse_clickhouse_data:
-    driver: local
-  langfuse_clickhouse_logs:
-    driver: local
-  langfuse_minio_data:
-    driver: local

scripts/setup_langfuse.sh

@@ -1,118 +0,0 @@
-#!/bin/bash
-
-# setup_langfuse.sh
-#
-# This script sets up and runs Langfuse locally for development and testing purposes.
-#
-# Key functionalities:
-# 1. Downloads the latest docker-compose.yaml from the Langfuse repository
-# 2. Starts Langfuse using Docker Compose with default initialization variables
-# 3. Waits for the service to be available
-# 4. Launches a browser to open the local Langfuse UI
-# 5. Prints login credentials from the environment file
-#
-# Usage:
-#   ./setup_langfuse.sh
-#
-# Requirements:
-#   - Docker
-#   - curl
-#   - A .env.langfuse.local file in the env directory
-#
-# Note: This script is intended for local development use only.
-
-set -e
-
-SCRIPT_DIR=$(realpath "$(dirname "${BASH_SOURCE[0]}")")
-LANGFUSE_DOCKER_COMPOSE_URL="https://raw.githubusercontent.com/langfuse/langfuse/main/docker-compose.yml"
-LANGFUSE_DOCKER_COMPOSE_FILE="langfuse-docker-compose.yaml"
-LANGFUSE_ENV_FILE="$SCRIPT_DIR/.env.langfuse.local"
-
-check_dependencies() {
-    local dependencies=("curl" "docker")
-    local missing_dependencies=()
-
-    for cmd in "${dependencies[@]}"; do
-        if ! command -v "$cmd" &> /dev/null; then
-            missing_dependencies+=("$cmd")
-        fi
-    done
-
-    if [ ${#missing_dependencies[@]} -ne 0 ]; then
-        echo "Missing dependencies: ${missing_dependencies[*]}"
-        exit 1
-    fi
-}
-
-download_docker_compose() {
-    if ! curl --fail --location --output "$SCRIPT_DIR/langfuse-docker-compose.yaml" "$LANGFUSE_DOCKER_COMPOSE_URL"; then
-        echo "Failed to download docker-compose file from $LANGFUSE_DOCKER_COMPOSE_URL"
-        exit 1
-    fi
-}
-
-start_docker_compose() {
-    docker compose --env-file "$LANGFUSE_ENV_FILE" -f "$LANGFUSE_DOCKER_COMPOSE_FILE" up --detach
-}
-
-wait_for_service() {
-    echo "Waiting for Langfuse to start..."
-    local retries=10
-    local count=0
-    until curl --silent http://localhost:3000 > /dev/null; do
-        ((count++))
-        if [ "$count" -ge "$retries" ]; then
-            echo "Max retries reached. Langfuse did not start in time."
-            exit 1
-        fi
-        sleep 1
-    done
-    echo "Langfuse is now available!"
-}
-
-launch_browser() {
-    if [[ "$OSTYPE" == "linux-gnu"* ]]; then
-        xdg-open "http://localhost:3000"
-    elif [[ "$OSTYPE" == "darwin"* ]]; then
-        open "http://localhost:3000"
-    else
-        echo "Please open http://localhost:3000 to view Langfuse traces."
-    fi
-}
-
-get_project_keys() {
-    local public_key
-    local secret_key
-    
-    if [ -f "$LANGFUSE_ENV_FILE" ]; then
-        # Try to get keys from env file
-        public_key=$(grep -E "^LANGFUSE_INIT_PROJECT_PUBLIC_KEY=" "$LANGFUSE_ENV_FILE" | cut -d'=' -f2)
-        secret_key=$(grep -E "^LANGFUSE_INIT_PROJECT_SECRET_KEY=" "$LANGFUSE_ENV_FILE" | cut -d'=' -f2)
-    fi
-    
-    # Use environment variables if set, otherwise use defaults
-    echo "export LANGFUSE_INIT_PROJECT_PUBLIC_KEY=${public_key:-$DEFAULT_PUBLIC_KEY}"
-    echo "export LANGFUSE_INIT_PROJECT_SECRET_KEY=${secret_key:-$DEFAULT_SECRET_KEY}"
-}
-
-print_login_variables() {
-    if [ -f "$LANGFUSE_ENV_FILE" ]; then
-        echo "If not already logged in use the following credentials to log in:"
-        grep -E "LANGFUSE_INIT_USER_EMAIL|LANGFUSE_INIT_USER_PASSWORD" "$LANGFUSE_ENV_FILE"
-    else
-        echo "Langfuse environment file with local credentials not found."
-    fi
-    echo
-    echo "Project keys (add these to your environment):"
-    get_project_keys
-    echo
-}
-
-check_dependencies
-pushd "$SCRIPT_DIR" > /dev/null
-download_docker_compose
-start_docker_compose
-wait_for_service
-print_login_variables
-launch_browser
-popd > /dev/null