Application Real-Time Monitoring Service:Install the ARMS agent for a Java application in Function Compute

Supported runtimes and requirements

To create a function with a custom runtime, see Create a function.

Step 1: Get a license key

Call the DescribeTraceLicenseKey API operation in OpenAPI Explorer to retrieve your ARMS license key. Save this key for use in Step 3.

Step 2: Add the ARMS agent layer

Function Compute provides official common layers that bundle the ARMS agent for each supported Java version.

Replace {region} with the region ID of your function, such as cn-hangzhou.

To add the layer in the Function Compute console:

1. Log on to the Function Compute console. In the left-side navigation pane, click Functions.

2. In the top navigation bar, select a region. On the Functions page, click the target function.

3. On the function details page, click the Configurations tab.

4. In the left-side navigation pane, click Layers, then click Modify.

5. In the Layers panel, choose + Add Layer > Add Official Common Layer, and select the ARMS agent layer that matches your Java version.

Step 3: Configure environment variables

Set the following environment variables for your function:

To set these variables in the Function Compute console:

1. On the function details page, click the Configurations tab.

2. In the left-side navigation pane, click Environment Variables, then click Modify.

3. Add FC_EXTENSION_ARMS=true and FC_EXTENSIONS_ARMS_LICENSE_KEY=<your-license-key>.

For more details, see Configure environment variables.

Step 4: Create a bootstrap script

The ARMS agent attaches to your Java process through JVM startup parameters. Create a bootstrap file to pass these parameters when the function starts.

The following table describes the required JVM parameters:

Example bootstrap script:

#!/bin/bash
set -eo pipefail

# Set the ARMS application name.
# Defaults to FC:{FunctionName} if the FC_FUNCTION_NAME variable exists.
appName="FC:Custom_Java_Arms_Demo"
if [ -n "${FC_FUNCTION_NAME}" ]; then
    appName="FC:${FC_FUNCTION_NAME}"
fi

echo "appName: ${appName}"
params=" "

# Build the ARMS JVM parameters.
if [[ -n "${FC_EXTENSIONS_ARMS_LICENSE_KEY}" ]]; then
    echo "FC_EXTENSIONS_ARMS_LICENSE_KEY: ${FC_EXTENSIONS_ARMS_LICENSE_KEY}"
    params+="-Dfc.instanceId=$HOSTNAME@`hostname -i` "
    params+="-javaagent:/opt/ArmsAgent/arms-bootstrap-1.7.0-SNAPSHOT.jar "
    params+="-Darms.licenseKey=${FC_EXTENSIONS_ARMS_LICENSE_KEY} "
    params+="-Darms.appName=${appName} "
else
    echo "The environment FC_EXTENSIONS_ARMS_LICENSE_KEY does not exist, please set the FC_EXTENSIONS_ARMS_LICENSE_KEY environment!"
    exit 1
fi

# Launch the application. Replace the JAR path with your own.
echo "params: ${params}"
exec java $params \
    -Dserver.port=9000 \
    -jar /code/target/demo-0.0.1-SNAPSHOT.jar

Replace /code/target/demo-0.0.1-SNAPSHOT.jar with the path to your application JAR file.

Step 5: Verify the integration

After deployment, invoke the function at least once to trigger data collection, then confirm that ARMS is receiving data:

1. Log on to the ARMS console.

2. In the left-side navigation pane, choose Application Monitoring > Applications.

3. Find the application whose name matches the appName value from your bootstrap script. The default is FC:{FunctionName}.

4. Click the application name to view traces, JVM metrics, and other monitoring data.

For details on the monitoring dashboard, see Application overview.

Billing

ARMS integration with Function Compute incurs charges from two services: