Optimize Elasticsearch 8 search performance with custom analyzers and field mappings

#!/usr/bin/env bash

set -euo pipefail

# Colors for output
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly NC='\033[0m' # No Color

# Global variables
ELASTICSEARCH_HOST="${1:-localhost}"
ELASTICSEARCH_PORT="${2:-9200}"
PKG_MGR=""
PKG_INSTALL=""

# Usage message
usage() {
    echo "Usage: $0 [elasticsearch_host] [elasticsearch_port]"
    echo "  elasticsearch_host: Elasticsearch host (default: localhost)"
    echo "  elasticsearch_port: Elasticsearch port (default: 9200)"
    exit 1
}

# Logging functions
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1" >&2; }

# Cleanup on failure
cleanup() {
    log_error "Script failed. Check the logs above for details."
}
trap cleanup ERR

# Check prerequisites
check_prerequisites() {
    echo "[1/6] Checking prerequisites..."
    
    if [[ $EUID -eq 0 ]]; then
        log_error "This script should not be run as root for security reasons"
        exit 1
    fi
    
    if ! command -v sudo >/dev/null 2>&1; then
        log_error "sudo is required but not installed"
        exit 1
    fi
    
    # Detect distribution
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        case "$ID" in
            ubuntu|debian)
                PKG_MGR="apt"
                PKG_INSTALL="apt install -y"
                ;;
            almalinux|rocky|centos|rhel|ol)
                PKG_MGR="dnf"
                PKG_INSTALL="dnf install -y"
                ;;
            fedora)
                PKG_MGR="dnf"
                PKG_INSTALL="dnf install -y"
                ;;
            amzn)
                PKG_MGR="yum"
                PKG_INSTALL="yum install -y"
                ;;
            *)
                log_error "Unsupported distribution: $ID"
                exit 1
                ;;
        esac
    else
        log_error "Cannot detect distribution"
        exit 1
    fi
    
    log_info "Detected distribution: $ID"
    log_info "Using package manager: $PKG_MGR"
}

# Install required packages
install_packages() {
    echo "[2/6] Installing required packages..."
    
    case "$PKG_MGR" in
        apt)
            sudo apt update
            sudo $PKG_INSTALL curl jq
            ;;
        dnf|yum)
            sudo $PKG_INSTALL curl jq
            ;;
    esac
    
    log_info "Required packages installed successfully"
}

# Check Elasticsearch connectivity
check_elasticsearch() {
    echo "[3/6] Checking Elasticsearch connectivity..."
    
    if ! curl -sf "http://${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}/_cluster/health" >/dev/null; then
        log_error "Cannot connect to Elasticsearch at ${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}"
        log_error "Please ensure Elasticsearch is running and accessible"
        exit 1
    fi
    
    log_info "Elasticsearch is accessible at ${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}"
}

# Create custom analyzers and index
create_analyzers() {
    echo "[4/6] Creating custom analyzers and index..."
    
    local response_code
    response_code=$(curl -s -o /dev/null -w "%{http_code}" -X PUT \
        "http://${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}/products_v1" \
        -H "Content-Type: application/json" \
        -d '{
            "settings": {
                "analysis": {
                    "tokenizer": {
                        "email_tokenizer": {
                            "type": "pattern",
                            "pattern": "([a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+)"
                        }
                    },
                    "filter": {
                        "product_synonym": {
                            "type": "synonym",
                            "synonyms": [
                                "laptop,notebook,computer",
                                "mobile,phone,smartphone",
                                "tv,television,monitor"
                            ]
                        },
                        "product_stemmer": {
                            "type": "stemmer",
                            "language": "english"
                        },
                        "edge_ngram_filter": {
                            "type": "edge_ngram",
                            "min_gram": 2,
                            "max_gram": 20
                        }
                    },
                    "analyzer": {
                        "product_search": {
                            "type": "custom",
                            "tokenizer": "standard",
                            "filter": ["lowercase", "product_synonym", "product_stemmer", "stop"]
                        },
                        "product_autocomplete": {
                            "type": "custom",
                            "tokenizer": "standard",
                            "filter": ["lowercase", "edge_ngram_filter"]
                        },
                        "email_analyzer": {
                            "type": "custom",
                            "tokenizer": "email_tokenizer",
                            "filter": ["lowercase"]
                        }
                    }
                }
            }
        }')
    
    if [[ "$response_code" != "200" && "$response_code" != "201" ]]; then
        log_error "Failed to create index with custom analyzers (HTTP $response_code)"
        exit 1
    fi
    
    log_info "Custom analyzers created successfully"
}

# Configure field mappings
configure_mappings() {
    echo "[5/6] Configuring optimized field mappings..."
    
    local response_code
    response_code=$(curl -s -o /dev/null -w "%{http_code}" -X PUT \
        "http://${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}/products_v1/_mapping" \
        -H "Content-Type: application/json" \
        -d '{
            "properties": {
                "title": {
                    "type": "text",
                    "analyzer": "product_search",
                    "fields": {
                        "autocomplete": {
                            "type": "text",
                            "analyzer": "product_autocomplete",
                            "search_analyzer": "standard"
                        },
                        "exact": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "description": {
                    "type": "text",
                    "analyzer": "product_search",
                    "index_options": "freqs",
                    "norms": false
                },
                "category": {
                    "type": "keyword",
                    "ignore_above": 64
                },
                "tags": {
                    "type": "keyword",
                    "ignore_above": 32
                },
                "price": {
                    "type": "scaled_float",
                    "scaling_factor": 100
                },
                "created_at": {
                    "type": "date",
                    "format": "strict_date_optional_time||epoch_millis"
                },
                "in_stock": {
                    "type": "boolean"
                },
                "metadata": {
                    "type": "object",
                    "enabled": false
                },
                "internal_id": {
                    "type": "keyword",
                    "index": false
                }
            }
        }')
    
    if [[ "$response_code" != "200" ]]; then
        log_error "Failed to configure field mappings (HTTP $response_code)"
        exit 1
    fi
    
    log_info "Field mappings configured successfully"
}

# Create index template
create_index_template() {
    echo "[6/6] Creating index template for consistency..."
    
    local response_code
    response_code=$(curl -s -o /dev/null -w "%{http_code}" -X PUT \
        "http://${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}/_index_template/products_template" \
        -H "Content-Type: application/json" \
        -d '{
            "index_patterns": ["products_*"],
            "priority": 100,
            "template": {
                "settings": {
                    "number_of_shards": 2,
                    "number_of_replicas": 1,
                    "refresh_interval": "5s",
                    "max_result_window": 50000
                }
            }
        }')
    
    if [[ "$response_code" != "200" ]]; then
        log_error "Failed to create index template (HTTP $response_code)"
        exit 1
    fi
    
    log_info "Index template created successfully"
}

# Verification
verify_setup() {
    echo
    log_info "Verifying Elasticsearch optimization setup..."
    
    # Check index exists and has custom analyzers
    if curl -sf "http://${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}/products_v1/_settings" | jq -e '.products_v1.settings.index.analysis.analyzer' >/dev/null; then
        log_info "✓ Custom analyzers are configured"
    else
        log_error "✗ Custom analyzers verification failed"
        exit 1
    fi
    
    # Check mappings are configured
    if curl -sf "http://${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}/products_v1/_mapping" | jq -e '.products_v1.mappings.properties.title' >/dev/null; then
        log_info "✓ Field mappings are configured"
    else
        log_error "✗ Field mappings verification failed"
        exit 1
    fi
    
    # Check index template exists
    if curl -sf "http://${ELASTICSEARCH_HOST}:${ELASTICSEARCH_PORT}/_index_template/products_template" >/dev/null; then
        log_info "✓ Index template is configured"
    else
        log_error "✗ Index template verification failed"
        exit 1
    fi
    
    echo
    log_info "Elasticsearch optimization completed successfully!"
    log_info "Index: products_v1"
    log_info "Template: products_template (applies to products_* indices)"
    log_info "Analyzers: product_search, product_autocomplete, email_analyzer"
}

# Main execution
main() {
    if [[ $# -gt 2 ]]; then
        usage
    fi
    
    check_prerequisites
    install_packages
    check_elasticsearch
    create_analyzers
    configure_mappings
    create_index_template
    verify_setup
}

main "$@"