Split Proxy

The Split Proxy enables you to deploy a service in your own infrastructure that behaves like Harness servers and is used by both server-side and client-side SDKs to synchronize the flags without connecting to Harness FME's actual backend directly.

This tool reduces connection latencies between the SDKs and Harness FME servers, and when a single connection is required from a private network to the outside for security reasons.

Architecture

Setup

Docker (recommended)

The service is available via Docker or command line, and its source code is available at the split-synchronizer GitHub site.

• Pull the image: docker pull splitsoftware/split-proxy

• Run as:

docker run --rm --name split-proxy \
 -p 3000:3000 \
 -p 3010:3010 \
 -e SPLIT_PROXY_APIKEY="your-sdk-key" \
 -e SPLIT_PROXY_CLIENT_APIKEYS="123456,qwerty" \
 splitsoftware/split-proxy

API KEYS

The SPLIT_PROXY_APIKEY is the server-side SDK API Key that you can find or create in Admin settings. The Split Proxy uses the SPLIT_PROXY_APIKEY to connect to Harness servers.

The SPLIT_PROXY_CLIENT_APIKEYS is a list of strings that the Split Proxy will use to authenticate a client. (A Split Proxy client is a client/server-side FME SDK instance that connects to Split Proxy.) The Split Proxy will validate the client by comparing the key the client provides with the strings listed in SPLIT_PROXY_CLIENT_APIKEYS. These keys can be any string, generated via any method of your choice. For example, you can generate a GUID or use the string "hello" (e.g. for initial setup and testing the connection). As long as the Proxy client supplies a string that is in the SPLIT_PROXY_CLIENT_APIKEYS list, the Proxy will accept the client and forward the request to Harness servers. The Split Proxy client (the client/server-side FME SDK instance) will supply a Split Proxy Client API Key in the usual place of the SDK Key.

Command line

To install and run the service from command line, depending of your platform, follow the steps below:

Linux

On Linux systems, invoke the Proxy service install script with the following:

curl -L -o install_linux.bin 'https://downloads.split.io/proxy/install_split_proxy_linux.bin' && chmod 755 install_linux.bin && ./install_linux.bin

OSX

On OSX systems, invoke the Proxy service install script with the following:

curl -L -o install_osx.bin 'https://downloads.split.io/proxy/install_split_proxy_osx.bin' && chmod 755 install_osx.bin && ./install_osx.bin

Windows

On Microsoft Windows systems, follow the steps below:

1. Download the app from https://downloads.split.io/proxy/split_proxy_windows.zip.

2. Unzip the downloaded file.

3. Run it.

DOWNLOAD PREVIOUS VERSIONS

The links above point to the latest version. To download a previous version of split-sync, go to https://downloads.split.io/proxy/downloads.proxy.html.

Run the service

To run the service, paste the following snippet into your command line terminal and add your SDK key.

Linux/Mac

split-proxy -apikey "your_sdk_key" -client-apikeys "your_client_key_1,your_client_key_2"

Windows

Open the cmd terminal or the PowerShell terminal, go to (cd) your unzipped Split Proxy folder, and type:

split-proxy -apikey "your_sdk_key" -client-apikeys "your_client_key_1,your_client_key_2"

Recommended configuration for production

You can run the service with the simple steps above, but the system is more stable in your production environment when you run the job with a scheduling system. We recommend starting the Proxy using supervisord, a daemon that launches other processes and ensures they stay running.

To use supervisord, make sure you install it on your machine. You can get help on the installation at the official Supervisord documentation.

After you install supervisord into your project, copy and paste the program below anywhere into the supervisord.conf file that should now be in your project.

[program:splitio_proxy]
command=/usr/local/bin/split-proxy -config /path/to/your/config.file.json
process_name = SplitIO
numprocs = 1
autostart=true
autorestart=true
user = your_user
stderr_logfile=/var/log/splitio.err.log
stderr_logfile_maxbytes = 1MB
stdout_logfile=/var/log/splitio.out.log
stdout_logfile_maxbytes = 1MB

Advanced configuration

The Proxy service has several knobs for configuring performance. Each knob is tuned to a reasonable default. However, you can override the default values by changing a splitio.config.json file or by setting your customer values as parameters of -config in the command line option. In this section, we lay out all the different knobs you can configure for performance, persistent storage, and logging.

The splitio.config.json file provided using the -config option lets you control how often the synchronizer fetches data from Harness servers. You can create a sample JSON file automatically with default values by running the following command:

./split-proxy -write-default-config "/home/someuser/splitio.config.json"

CONFIGURATION PATH FILE

Save the JSON config file on your server in your desired folder. For example, on Linux systems, you can save it in the etc folder. Be sure to set the right path as the -config parameter.

{
  "apikey": "YOUR_SDK_KEY",
  "ipAddressEnabled": true,
  "initialization": {
    "timeoutMS": 10000,
    "snapshot": "",
  },
  "server": {
    "apikeys": [
      "YOUR_SDK_KEY"
    ],
    "host": "0.0.0.0",
    "port": 3000,
    "httpCacheSize": 1000000
  },
  "admin": {
    "host": "0.0.0.0",
    "port": 3010,
    "username": "",
    "password": "",
    "secureChecks": false
  },
  "storage": {
    "volatile": {},
    "persistent": {
      "filename": ""
    }
  },
  "sync": {
    "splitRefreshRateMs": 60000,
    "segmentRefreshRateMs": 60000,
    "advanced": {
      "streamingEnabled": true,
      "httpTimeoutMs": 30000,
      "impressionsBufferSize": 500,
      "eventsBufferSize": 500,
      "telemetryBufferSize": 500,
      "impressionsWorkers": 10,
      "eventsWorkers": 10,
      "telemetryWorkers": 10,
      "internalTelemetryRateMs": 3600000
    }
  },
  "integrations": {
    "impressionListener": {
      "endpoint": "",
      "queueSize": 100
    },
    "slack": {
      "webhook": "",
      "channel": ""
    }
  },
  "logging": {
    "level": "info",
    "output": "stdout",
    "rotationMaxFiles": 10,
    "rotationMaxSizeKb": 0
  },
  "healthcheck": {
    "dependencies": {
      "dependenciesCheckRateMs": 3600000
    }
  }
}

COMMAND LINE PARAMETERS

All available options in the JSON file are also included as command line options. Run the command followed by the -help option to see more details, or just keep reading this documentation page.

Methods to Configure the Split Proxy

You can configure the Split Proxy using the command line or by directly editing the above mentioned JSON configuration file.

CONFIG VALUES PRIORITY

All config values are set with a default value that you can see in the example JSON file above. You can overwrite the default value from the JSON config file, and you can overwrite the JSON config file from the command line. Refer to the sample below for how to do that using the command line.

split-proxy -config "/etc/splitio.config.json" -log-level=info -admin-username="admin" -admin-password="somePass" 

CLI Configuration options and its equivalents in JSON and Environment variables

The following table includes the available command line, JSON, and environment variable options and their descriptions. It specifies configuration options for the Split Synchronizer. You can configure the synchronizer using command line arguments, environment variables when you run it as a docker container, and a JSON file when you run it locally. All of these configuration options can be used regardless of the configuration method.

SPLIT PROXY V5.0 BOOLEAN OPTIONS CHANGE

With the Split Synchronizer v5.0.0, the only accepted values for boolean flags are "true" and "false" in lowercase. Values such as "enabled", "on", "yes", or "True" result in an error when you start up. This applies to JSON, CLI arguments, and environment variables.

Command line option	JSON option	Environment variable (container-only)	Default Value	Description
log-level	level	SPLIT_PROXY_LOG_LEVEL	info	Log level: error, warning, info, debug, or verbose.
log-output	output	SPLIT_PROXY_LOG_OUTPUT	stdout	Where to output logs.
log-rotation-max-files	rotationMaxFiles	SPLIT_PROXY_LOG_ROTATION_MAX_FILES	10	Maximum number of files to keep when rotating logs.
log-rotation-max-size-kb	rotationMaxSizeKb	SPLIT_PROXY_LOG_ROTATION_MAX_SIZE_KB	1024	Maximum log file size in KB before rotating.
admin-host	host	SPLIT_PROXY_ADMIN_HOST	0.0.0.0	Host where the admin server will listen.
admin-port	port	SPLIT_PROXY_ADMIN_PORT	3010	Admin port where incoming connections will be accepted.
admin-username	username	SPLIT_PROXY_ADMIN_USERNAME	ADMIN_USERNAME	HTTP basic auth username for admin endpoints.
admin-password	password	SPLIT_PROXY_ADMIN_PASSWORD	ADMIN_PASSWORD	HTTP basic auth password for admin endpoints.
admin-secure-hc	secureChecks	SPLIT_PROXY_ADMIN_SECURE_HC	false	Secures health check endpoints.
admin-tls-enabled	enabled	SPLIT_PROXY_ADMIN_TLS_ENABLED	false	Enable HTTPS on proxy endpoints.
admin-tls-client-validation	clientValidation	SPLIT_PROXY_ADMIN_TLS_CLIENT_VALIDATION	false	Enable client certificate validation.
admin-tls-server-name	serverName	SPLIT_PROXY_ADMIN_TLS_SERVER_NAME	Empty	Server name as it appears in the provided server certificate.
admin-tls-cert-chain-fn	certChainFn	SPLIT_PROXY_ADMIN_TLS_CERT_CHAIN_FN	Empty	X509 Server certificate chain.
admin-tls-private-key-fn	privateKeyFn	SPLIT_PROXY_ADMIN_TLS_PRIVATE_KEY_FN	Empty	PEM private key file name.
admin-tls-client-validation-root-cert	clientValidationRootCertFn	SPLIT_PROXY_ADMIN_TLS_CLIENT_VALIDATION_ROOT_CERT	Empty	X509 root certificate for client validation.
admin-tls-min-tls-version	minTlsVersion	SPLIT_PROXY_ADMIN_TLS_MIN_TLS_VERSION	1.3	Minimum TLS version allowed.
admin-tls-allowed-cipher-suites	allowedCipherSuites	SPLIT_PROXY_ADMIN_TLS_ALLOWED_CIPHER_SUITES	Empty	Comma-separated list of allowed cipher suites.
impression-listener-endpoint	endpoint	SPLIT_PROXY_IMPRESSION_LISTENER_ENDPOINT	Empty	HTTP endpoint to forward impressions.
impression-listener-queue-size	queueSize	SPLIT_PROXY_IMPRESSION_LISTENER_QUEUE_SIZE	100	Maximum number of impression bulks to queue.
slack-webhook	webhook	SPLIT_PROXY_SLACK_WEBHOOK	Empty	Slack webhook to post log messages.
slack-channel	channel	SPLIT_PROXY_SLACK_CHANNEL	Empty	Slack channel to post log messages.
apikey	apikey	SPLIT_PROXY_APIKEY	API_KEY	FME server-side SDK API key.
ip-address-enabled	ipAddressEnabled	SPLIT_PROXY_IP_ADDRESS_ENABLED	true	Bundle host's IP address when sending data to Harness FME.
timeout-ms	timeoutMS	SPLIT_PROXY_TIMEOUT_MS	10000	How long to wait until the synchronizer is ready.
snapshot	snapshot	SPLIT_PROXY_SNAPSHOT	Empty	Snapshot file to use as a starting point.
client-apikeys	apikeys	SPLIT_PROXY_CLIENT_APIKEYS	SDK_API_KEY	API keys that clients connecting to this proxy will use.
server-host	host	SPLIT_PROXY_SERVER_HOST	0.0.0.0	Host/IP to start the proxy server on.
server-port	port	SPLIT_PROXY_SERVER_PORT	3000	Port to listen for incoming requests from SDKs.
server-tls-enabled	enabled	SPLIT_PROXY_SERVER_TLS_ENABLED	false	Enable HTTPS on proxy endpoints.
server-tls-client-validation	clientValidation	SPLIT_PROXY_SERVER_TLS_CLIENT_VALIDATION	false	Enable client certificate validation.
server-tls-server-name	serverName	SPLIT_PROXY_SERVER_TLS_SERVER_NAME	Empty	Server name as it appears in the provided server certificate.
server-tls-cert-chain-fn	certChainFn	SPLIT_PROXY_SERVER_TLS_CERT_CHAIN_FN	Empty	X509 server certificate chain.
server-tls-private-key-fn	privateKeyFn	SPLIT_PROXY_SERVER_TLS_PRIVATE_KEY_FN	Empty	PEM private key file name.
server-tls-client-validation-root-cert	clientValidationRootCertFn	SPLIT_PROXY_SERVER_TLS_CLIENT_VALIDATION_ROOT_CERT	Empty	X509 root certificate for client validation.
server-tls-min-tls-version	minTlsVersion	SPLIT_PROXY_SERVER_TLS_MIN_TLS_VERSION	1.3	Minimum TLS version allowed.
server-tls-allowed-cipher-suites	allowedCipherSuites	SPLIT_PROXY_SERVER_TLS_ALLOWED_CIPHER_SUITES	Empty	Comma-separated list of allowed cipher suites.
http-cache-size	httpCacheSize	SPLIT_PROXY_HTTP_CACHE_SIZE	1000000	How many responses to cache.
persistent-storage-fn	filename	SPLIT_PROXY_PERSISTENT_STORAGE_FN	Empty	Where to store flags and user-generated data (defaults to a temporary file).
split-refresh-rate-ms	splitRefreshRateMs	SPLIT_PROXY_SPLIT_REFRESH_RATE_MS	60000	How often to refresh feature flags.
segment-refresh-rate-ms	segmentRefreshRateMs	SPLIT_PROXY_SEGMENT_REFRESH_RATE_MS	60000	How often to refresh segments.
streaming-enabled	streamingEnabled	SPLIT_PROXY_STREAMING_ENABLED	true	Enable/disable streaming functionality.
http-timeout-ms	httpTimeoutMs	SPLIT_PROXY_HTTP_TIMEOUT_MS	30000	Total HTTP request timeout.
impressions-workers	impressionsWorkers	SPLIT_PROXY_IMPRESSIONS_WORKERS	10	Number of workers to forward impressions to Harness servers.
events-workers	eventsWorkers	SPLIT_PROXY_EVENTS_WORKERS	10	Number of workers to forward events to Harness servers.
telemetry-workers	telemetryWorkers	SPLIT_PROXY_TELEMETRY_WORKERS	10	Number of workers to forward telemetry to Harness servers.
internal-metrics-rate-ms	internalTelemetryRateMs	SPLIT_PROXY_INTERNAL_METRICS_RATE_MS	3600000	How often to send internal metrics.
dependencies-check-rate-ms	dependenciesCheckRateMs	SPLIT_PROXY_DEPENDENCIES_CHECK_RATE_MS	3600000	How often to check dependencies health.

Listener

The Split Proxy provides an impression listener that bulks post impressions to a user-defined HTTP endpoint.

The endpoint should expect a POST request that contains a JSON body using the following format:

{
 "impressions": [
  {
   "testName": "feature1",
   "keyImpressions": [
    {
     "keyName": "user1",
     "treatment": "on",
     "time": 1502754901182,
     "changeNumber": -1,
     "label": ""
    },
    {
     "keyName": "user2",
     "treatment": "off",
     "time": 1502754876144,
     "changeNumber": -1,
     "label": ""
    }
   ]
  }
 ],
 "sdkVersion": "php-5.2.2",
 "machineIP": "208.63.222.7",
 "MachineName": ""
}

The configuration options are available in the integrations.impressionListener section of the JSON configuration file detailed in the Advanced configuration section.

Using a network proxy

If you need to use a network proxy, configure the proxies by setting the environment variables as HTTP_PROXY and HTTPS_PROXY. The internal HTTP client reads those variables and uses them to perform a server request.

For example:

$ export HTTP_PROXY="http://10.10.1.10:3128"
$ export HTTPS_PROXY="http://10.10.1.10:1080"

Using FME SDKs with the Split Proxy

All FME SDKs can connect to a Split Proxy instance instead of making requests directly to Split's cloud services. This is useful for environments that require controlled network access, reduced latency, or caching through the proxy.

To enable this connection, first obtain the full Split Proxy URL from your administrator. Then, update your SDK configuration to point to this URL.

Each SDK requires you to specify the proxy endpoints explicitly by setting configuration parameters corresponding to the SDK, events, authentication, and telemetry service URLs. For examples, the JavaScript SDK expects these URLs in the urls config object and the Python SDK accepts parameters such as sdk_api_base_url and events_api_base_url. See the SDK-specific documentation for the exact parameter names and how to set them.

JavaScript SDK

core: { ... },
urls: {
    sdk: 'http://ProxyServerName:Port/api',
    events: 'http://ProxyServerName:Port/api',
    auth: 'https://ProxyServerName:Port/api',
},

Android SDK

final ServiceEndpoints serviceEndpoints = ServiceEndpoints.builder()
    .apiEndpoint("http://ProxyServerName:Port/api")
    .eventsEndpoint("http://ProxyServerName:Port/api")
    .sseAuthServiceEndpoint("http://ProxyServerName:Port/api")
    .streamingServiceEndpoint("http://ProxyServerName:Port/api")
    .telemetryServiceEndpoint("http://ProxyServerName:Port/api")
    .build();

SplitClientConfig config = SplitClientConfig.builder()
    .serviceEndpoints(serviceEndpoints)
    .build();

iOS SDK

let endpoints: ServiceEndpoints = ServiceEndpoints.builder()
    .set(sdkEndpoint: "http://ProxyServerName:Port/api")
    .set(eventsEndpoint: "http://ProxyServerName:Port/api")
    .set(authServiceEndpoint: "http://ProxyServerName:Port/api")
    .set(telemetryServiceEndpoint: "http://ProxyServerName:Port/api")
    .build()

let config = SplitClientConfig()
config.serviceEndpoints = endpoints

Java SDK

SplitClientConfig config = SplitClientConfig.builder()
    .endpoint("http://ProxyServerName:Port", "http://ProxyServerName:Port")
    .authServiceURL("http://ProxyServerName:Port")
    .telemetryURL("http://ProxyServerName:Port")
    .build();

Ruby SDK

options = {
    base_uri: "http://ProxyServerName:Port/api"
    events_uri: "http://ProxyServerName:Port/api"
    auth_service_url: "http://ProxyServerName:Port/api"
    telemetry_service_url: 'http://ProxyServerName:Port/api',
    streaming_service_url: 'http://ProxyServerName:Port/api'
}

Python SDK

config = {}
factory = get_factory(
    'YOUR_API_KEY',
    config=config,
    sdk_api_base_url='http://ProxyServerName:Port/api',
    events_api_base_url='http://ProxyServerName:Port/api'
)

Go SDK

cfg := conf.Default()
cfg.Advanced.AuthServiceURL = "http://ProxyServerName:Port/api"
cfg.Advanced.SdkURL = "http://ProxyServerName:Port/api"
cfg.Advanced.EventsURL = "http://ProxyServerName:Port/api"
cfg.Advanced.TelemetryServiceURL = "http://ProxyServerName:Port/api"

.NET SDK

var config = new ConfigurationOptions
{
    Endpoint = "http://ProxyServerName:Port",
    EventsEndpoint = "http://ProxyServerName:Port",
    AuthServiceURL = "http://ProxyServerName:Port/api/v2/auth",",
    StreamingServiceURL = "http://ProxyServerName:Port/sse",
    TelemetryServiceURL = "http://ProxyServerName:Port/api/v1"
};

Once configured, the SDK routes all traffic through the Split Proxy, allowing it to serve requests locally without needing direct internet access to Split's public endpoints.

Admin tools

Endpoints

The split-proxy service has a set of endpoints and a dashboard that lets the DevOps and infra team monitor its status and cached data in real-time. By default, the port is 3010 and for security reason, it supports HTTP Basic Authentication configured by the user.

/info/ping

A ping endpoint to monitor the service status. If the service is running, it sends the text response pong and the HTTP status code 200.

/info/version

Returns the split-proxy version in JSON format.

{
  "version" : "1.1.0"
}

/info/uptime

Returns the uptime string representation in JSON format.

{
  "uptime" : "5d 3h 36m 39s"
}

/info/config

Returns a JSON object describing the current configuration of the proxy.

{
  "config": {
    "apikey": "*",
    "ipAddressEnabled": true,
    "initialization": {
      "timeoutMS": 10000,
      "snapshot": "",
    },
    "server": {
      "apikeys": [
        "YOUR_SDK_KEY"
      ],
      "host": "0.0.0.0",
      "port": 3000,
      "httpCacheSize": 1000000
    },
    "admin": {
      "host": "0.0.0.0",
      "port": 3010,
      "username": "",
      "password": "",
      "secureChecks": false
    },
    "storage": {
      "volatile": {},
      "persistent": {
        "filename": ""
      }
    },
    "sync": {
      "splitRefreshRateMs": 60000,
      "segmentRefreshRateMs": 60000,
      "advanced": {
        "streamingEnabled": true,
        "httpTimeoutMs": 30000,
        "impressionsBufferSize": 500,
        "eventsBufferSize": 500,
        "telemetryBufferSize": 500,
        "impressionsWorkers": 10,
        "eventsWorkers": 10,
        "telemetryWorkers": 10,
        "internalTelemetryRateMs": 3600000
      }
    },
    "integrations": {
      "impressionListener": {
        "endpoint": "",
        "queueSize": 100
      },
      "slack": {
        "webhook": "",
        "channel": ""
      }
    },
    "logging": {
      "level": "info",
      "output": "stdout",
      "rotationMaxFiles": 10,
      "rotationMaxSizeKb": 0
    },
    "healthcheck": {
      "dependencies": {
        "dependenciesCheckRateMs": 3600000
      }
    }
  }
}

/health/application

Returns a JSON object describing whether the proxy is healthy or not.

{
  "healthy": true,
  "healthySince": "2021-11-20T19:17:23.372708-03:00",
  "items": [
    {
      "name": "Feature flags",
      "healthy": true,
      "lastHit": "2021-11-20T19:17:36.147349-03:00"
    },
    {
      "name": "Segments",
      "healthy": true,
      "lastHit": "2021-11-20T19:17:36.324172-03:00"
    }
  ]
}

/health/dependencies

Returns a JSON object describing whether the servers the proxy depends on are healthy or not.

{
  "serviceStatus": "healthy",
  "dependencies": [
    {
      "service": "https://telemetry.split.io/health",
      "healthy": true,
      "healthySince": "2021-11-20T19:17:23.372741-03:00"
    },
    {
      "service": "https://auth.split.io/health",
      "healthy": true,
      "healthySince": "2021-11-20T19:17:23.372752-03:00"
    },
    {
      "service": "https://sdk.split.io/api/version",
      "healthy": true,
      "healthySince": "2021-11-20T19:17:23.372753-03:00"
    },
    {
      "service": "https://events.split.io/api/version",
      "healthy": true,
      "healthySince": "2021-11-20T19:17:23.372755-03:00"
    },
    {
      "service": "https://streaming.split.io/health",
      "healthy": true,
      "healthySince": "2021-11-20T19:17:23.372755-03:00"
    }
  ]
}

/admin/snapshot

Returns a binary snapshot file that can be used with the snapshot environment variable or command line argument when starting up the Split Proxy.

Observability

The Split Proxy exposes an observability endpoint that provides insights into both cached data and incoming SDK requests. This includes request volume, latency distribution, and HTTP response status codes, allowing you to monitor how the Proxy is handling traffic in real time.

You can use this endpoint in versions 5.0.3 or later to debug SDK traffic and Proxy performance. If HTTP Basic Authentication is enabled, include credentials (for example, using --user with curl).

GET http://<SERVER_HOST>:<SERVER_PORT>/admin/observability

The following metrics are available:

Metric	Category	Description
Active segments	Cache state	Map of segment names to key counts.
Active splits	Cache state	List of feature flags currently loaded.
Request count per endpoint	SDK traffic and performance	Total number of requests received per endpoint.
HTTP status codes	SDK traffic and performance	Count of responses grouped by HTTP status code.
Latency distribution	SDK traffic and performance	Distribution of request latencies across predefined buckets.

Metrics are aggregated into time slices within the proxyEndpointStats field. Each time slice represents a fixed time window and contains aggregated metrics for SDK requests handled during that period.

You can configure the number and duration of time slices using the following environment variables:

• SPLIT_PROXY_OBSERVABILITY_TIME_SLICE_MAX_COUNTS

• SPLIT_PROXY_OBSERVABILITY_TIME_SLICE_WIDTH_SECS

Latency buckets

Latency is reported using pre-defined buckets based on an increasing sequence of time ranges in milliseconds.

These buckets follow a progressively increasing scale (similar to a Fibonacci sequence), allowing you to capture both low-latency and high-latency requests with appropriate granularity.

Each bucket represents the number of requests completed within a specific time range (for example, 0–1 ms, 1–1.5 ms, and higher ranges). This helps you understand the distribution of request latency rather than relying on averages.

Example response

{
  "activeSegments": {
    "employees": 9984
  },
  "activeSplits": [
    "admin_panel"
  ],
  "proxyEndpointStats": [
    {
      "timeslice": 1650388500,
      "resources": {
        "auth": {
          "latencies": [5, 3, 2, 0, 0, 0],
          "requestCount": 10,
          "statusCodes": {
            "200": 10
          }
        }
      }
    }
  ]
}

The latencies array contains counts for each latency bucket, ordered from lowest to highest response time. Use this endpoint to validate that your Proxy is receiving traffic and serving feature flags correctly.

Admin Dashboard

Split Proxy has a web admin user interface out of the box that exposes all available endpoints. Browse to /admin/dashboard to see it.

The dashboard is organized into four sections for easy visualization:

• Dashboard: Tile-sorted summary information, including these metrics:

  • Uptime: Uptime metric

  • Healthy Since: Time passed without errors

  • Logged Errors: Total count of error messages

  • SDKs Total Hits: Total SDKs requests

  • Backend Total Hits: Total backend requests between split-proxy and Harness servers

  • Cached Feature flags: Number of feature flags cached in memory

  • Cached Segments: Number of segments cached in memory

  • SDK Server: displays the status of server for SDK

  • Events Server: displays the status of server for Events

  • Streaming Server: displays the status of streaming service

  • Auth Server: displays the status of server for initial streaming authentication

  • Telemetry Server: displays the status of server for telemetry capturing

  • Storage: (only Sync mode) displays the status of the storage

  • Sync: displays the status of the Proxy

  • Last Errors Log: List of the last 10 error messages

• SDK stats: Metrics numbers and a latency graph, measured between SDKs requests integration and proxy

• Split stats: Metrics numbers and a latency graph, measured between proxy requests integration with Harness servers

• Data inspector: Cached data showing feature flags and segments; filters to find keys and feature flag definitions

DASHBOARD REFRESH RATE

The dashboard numbers are committed every 60 seconds. The Logged Errors, Last Errors Log tiles, and Data inspector section are populated each time the dashboard is refreshed.

For Impressions and Events Queue size, the numbers are refreshed every 10 seconds.

Service shutdown

The split-proxy service can catch a kill sig command and start a graceful shutdown, flushing all cached data progressively. Additionally, you can perform graceful stop and force stop (kill -9) with one click from the admin dashboard.

If you configure a Slack channel and a Slack Webhook URL, an alert is sent to the channel when an initialization or shutdown is performed.