Health Check Overview - View Platform

Overview

Health check functionality provides comprehensive system monitoring and service health validation capabilities within the View platform. It enables monitoring of all platform services including switchboard, configuration, storage, vector, processor, assistant, orchestrator, crawler, lexi, embeddings, and director services for optimal system reliability and performance.

Health check operations are accessible via the View platform API and support monitoring of all critical platform components for comprehensive system health validation.

API Endpoints

HEAD / - Check server health (switchboard)
HEAD /healthcheck/config - Check configuration server health
HEAD /healthcheck/storage-rest - Check storage server health
HEAD /healthcheck/vector - Check vector server health
HEAD /healthcheck/processor - Check processor server health
HEAD /healthcheck/assistant - Check assistant server health
HEAD /healthcheck/orchestrator - Check orchestrator server health
HEAD /healthcheck/crawler - Check crawler server health
HEAD /healthcheck/lexi - Check lexi server health
HEAD /healthcheck/embeddings - Check embeddings server health
HEAD /healthcheck/director - Check director server health

SDK Setup

JavaScript SDK Setup

Install SDK from npm

npm install view-sdk

Initialize Configuration Sdk

import { ViewHealthcheckSdk } from "view-sdk";

const check = new ViewHealthcheckSdk(
  "<tenant-guid>", //tenant Id
  "default", //access token
  "http://localhost:8501/" //endpoint
);

Python setup

Install SDK from pip

pip install view-sdk

Initialize Configuration Sdk

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "<tenant-guid>")

Check server health

To check server health, call HEAD <endpoint>

curl --location --head 'http://view.homedns.org:8000/' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkSwitchboardHealth = async () => {
  try {
    const response = await api.healthCheck.checkSwitchboard();
    console.log(response);
  } catch (err) {
    console.log("Error checking switchboard health:", err);
  }
};

checkSwitchboardHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkServer():
    result = health_check.SwitchBoard.check()
    print(result)

checkServer()

Check config health

To check config server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/config' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkConfigHealth = async () => {
  try {
    const response = await api.healthCheck.checkConfig();
    console.log(response);
  } catch (err) {
    console.log("Error checking config health:", err);
  }
};

checkConfigHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkConfiguration():
    result = health_check.HealthCheck.configuration()
    print(result)

checkConfiguration()

Check storage health

To check storage server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/storage-rest' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);


const checkStorageHealth = async () => {
  try {
    const response = await api.healthCheck.checkStorage();
    console.log(response);
  } catch (err) {
    console.log("Error checking storage health:", err);
  }
};
checkStorageHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkStorage():
    result = health_check.HealthCheck.storage()
    print(result)

checkStorage()

Check vector health

To check vector server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/vector' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkVectorHealth = async () => {
  try {
    const response = await api.healthCheck.checkVector();
    console.log(response);
  } catch (err) {
    console.log("Error checking vector store health:", err);
  }
};
checkVectorHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkVector():
    result = health_check.HealthCheck.vector()
    print(result)

checkVector()

Check processor health

To check processor server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/processor' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);


const checkProcessorHealth = async () => {
  try {
    const response = await api.healthCheck.checkProcessor();
    console.log(response);
  } catch (err) {
    console.log("Error checking processor health:", err);
  }
};
checkProcessorHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkProcessor():
    result = health_check.HealthCheck.processor()
    print(result)

checkProcessor()

Check assistant health

To check assistant server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/assistant' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkAssistantHealth = async () => {
  try {
    const response = await api.healthCheck.checkAssistant();
    console.log(response);
  } catch (err) {
    console.log("Error checking assistant health:", err);
  }
};
checkAssistantHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkAssistant():
    result = health_check.HealthCheck.assistant()
    print(result)

checkAssistant()

Check orchestrator health

To check orchestrator server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/orchestrator' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkOrchestratorHealth = async () => {
  try {
    const response = await api.healthCheck.checkOrchestrator();
    console.log(response);
  } catch (err) {
    console.log("Error checking orchestrator health:", err);
  }
};
checkOrchestratorHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkOrchestrator():
    result = health_check.HealthCheck.orchestrator()
    print(result)

checkOrchestrator()

Check crawler health

To check crawler server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/crawler' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkCrawlHealth = async () => {
  try {
    const response = await api.healthCheck.checkCrawler();
    console.log(response);
  } catch (err) {
    console.log("Error checking crawl health:", err);
  }
};
checkCrawlHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkCrawler():
    result = health_check.HealthCheck.crawler()
    print(result)

checkCrawler()

Check lexi health

To check lexi server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/lexi' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkLexiconHealth = async () => {
  try {
    const response = await api.healthCheck.checkLexi();
    console.log(response);
  } catch (err) {
    console.log("Error checking lexicon health:", err);
  }
};
checkLexiconHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkLexi():
    result = health_check.HealthCheck.lexi()
    print(result)

checkLexi()

Check embeddings health

To check embeddings server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/embeddings' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);


const checkEmbeddingHealth = async () => {
  try {
    const response = await api.healthCheck.checkEmbeddings();
    console.log(response);
  } catch (err) {
    console.log("Error checking embedding health:", err);
  }
};
checkEmbeddingHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkEmbedding():
    result = health_check.HealthCheck.embeddings()
    print(result)

checkEmbedding()

Check director health

To check director server health, call HEAD /healthcheck/config

curl --location --head 'http://view.homedns.org:8000/healthcheck/director' \
--header 'Authorization: ••••••'

import { ViewHealthcheckSdk } from "view-sdk";

const api = new ViewHealthcheckSdk(
  "http://localhost:8501/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access token
);

const checkDirectorHealth = async () => {
  try {
    const response = await api.healthCheck.checkDirector();
    console.log(response);
  } catch (err) {
    console.log("Error checking directory health:", err);
  }
};
checkDirectorHealth();

import view_sdk
from view_sdk import health_check

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "00000000-0000-0000-0000-000000000000")

def checkDirector():
    result = health_check.HealthCheck.director()
    print(result)

checkDirector()

Best Practices

When implementing health check functionality in the View platform, consider the following recommendations for optimal system monitoring, service health validation, and platform reliability:

Comprehensive Monitoring: Implement health checks for all critical platform services to ensure comprehensive system monitoring and early issue detection
Regular Health Checks: Establish regular health check schedules to monitor service availability and performance continuously
Error Handling: Implement robust error handling and alerting mechanisms for health check failures and service degradation
Performance Monitoring: Monitor health check response times and service performance metrics for optimal system reliability
Service Dependencies: Understand service dependencies and implement health check strategies that account for inter-service relationships

Next Steps

After successfully implementing health check functionality, you can:

Monitoring Integration: Integrate health check results with monitoring and alerting systems for comprehensive platform oversight
Service Management: Use health check data for service management, scaling, and optimization decisions
Troubleshooting: Leverage health check information for rapid troubleshooting and issue resolution
Performance Optimization: Use health check metrics for performance optimization and capacity planning
Automation: Implement automated responses to health check failures for improved system reliability and availability