You are recommended to monitor the performance of the Synthetic Server with the Java Agent. Once you have instrumented the Synthetic Server, you can use preset capacity monitoring dashboards and health rules or create custom dashboards and health rules based on JMX and the Synthetic Server metrics. 

 Follow the steps below to monitor the Synthetic Server:

Install the Java Agent

You should install the Java Agent in the same directory as the Synthetic Server installation directory. See Install the Java Agent for instructions.

Configure the Java Agent

 Configure the Java Agent to report metrics to a specific Controller:

  1. Change to <agent_home>/conf/.
  2. Edit the controller-info.xml file so that the values for the following elements match your Controller information, application name, tier name, and node name:
    • <controller-host>
    • <controller-port>
    • <application-name>
    • <tier-name>
    • <node-name>

  3. For example, your controller-info.xml file might look similar to the following:

    <controller-info>
    <controller-host>192.168.1.20</controller-host>
    <controller-port>8090</controller-port>
    <application-name>SyntheticServer</application-name>
    <tier-name>SchedulerTier</tier-name>
    <node-name>SchedulerNode</node-name>
</controller-info>
    XML

    You just need to make sure that they are the same as those when you attach the Java Agent to the Synthetic Server.

Connect the Synthetic Server with the Controller

Before you installed the Synthetic Server, you needed to configure the Synthetic Server to connect to the EUM Server's MySQL database and the EUM Collector. In this section, you will set configurations in inputs.groovy to connect the Synthetic Server to the Controller, so that the predefined health rules and dashboards can be created.

In the inputs.groovy file, make sure you have set the properties below. Replace placeholders in brackets with information about your Controller as well as the application and tier that are being monitored.

controller_host = "http(s)://<url_to_machine_running_controller>"     // The URL to your on-prem Controller
controller_port = "<port_number>"                                     // The default is 8090.
controller_account = "<controller_account>"                           // Account used for running post-deploy tasks
controller_username = "<controller_username>"                         // Username for making API calls to controller
prompt_for_password = "false"                                         // When false, the password below will be used without prompting.
controller_password = "<controller_password>"                         // Password used for username. It is not stored in any config files.
controller_synth_app = "<app_name_set_in_controller-info.xml>"        // This is the application shown in the Controller and is based on the value given in the <application-name> element in controller-info.xml.
controller_shepherd_entity = "<tier_name_set_in_controller-info.xml>" // This is the tier shown in the Controller and is based on the value given in the <tier-name> element in controller-info.xml
TEXT

Attach the Java Agent to the Synthetic Server

To attach the Java Agent to the Synthetic Server, set Java options through the variables SCHEDULER_OPTS and SYNTHETIC_SHEPHERD_OPTS. The node names and tier names given in the examples below can be modified for your use case. One JVM process requires one Java Agent to be attached. 

  1. Set the options for the Synthetic Scheduler so that the Java Agent is attached to the JVM process:

    SCHEDULER_OPTS="-javaagent:./java_agent/javaagent.jar -Dappdynamics.agent.applicationName=synthonprem -Dappdynamics.agent.nodeName=synthetic-scheduler -Dappdynamics.agent.tierName=scheduler-tier"
    BASH

  2. Set the options for the Synthetic Shepherd so that the Java Agent is attached to the JVM process:

    SYNTHETIC_SHEPHERD_OPTS="-javaagent:./java_agent/javaagent.jar -Dappdynamics.agent.applicationName=synthonprem -Dappdynamics.agent.nodeName=synthetic-shepherd -Dappdynamics.agent.tierName=shepherd-tier"
    BASH

  3. Set the options for the Synthetic Feeder Client so that the Java Agent is attached to the JVM process:

    FEEDER_CLIENT_OPTS="-javaagent:./java_agent/javaagent.jar -Dappdynamics.agent.applicationName=synthonprem -Dappdynamics.agent.nodeName=synthetic-feeder-client -Dappdynamics.agent.tierName=feeder-client-tier"
    BASH

  4. Export the variables for the Synthetic Server options:

    export SYNTHETIC_SHEPHERD_OPTS
export SCHEDULER_OPTS
export FEEDER_CLIENT_OPTS
    BASH

  5. From the Synthetic Server installer directory, run the following to stop and start the Synthetic Server: 

    unix/deploy.sh stop
unix/deploy.sh start
    BASH

Verify the Instrumentation of the Synthetic Server

  1. Confirm that the Java Agent is running:

    ps -ef | grep javaagent
    BASH

  2. Check the Java Agent logs:

    tail <java-agent>/ver<agent-version>/logs/<node-name>/agent-XXXX.log
    BASH

  3. Navigate to your Controller.

  4. You should see a business application with the name assigned in the controller-info.xml file similar to the following. You should also see the tiers and nodes specified in the Java options.

Create Preset Dashboards and Health Rules

The Synthetic Server comes with the post_deploy.sh command to help create preset dashboards and health rules to monitor the Synthetic Server. The health rules are based on metrics generated by Synthetic Shepherd and not the host machine of the Synthetic Agent or the Java Agent, so they serve to complement the JMX health rules such as CPU usage, memory consumption, etc. 

About the Preset Dashboards and Health Rules

The preset health rules issue warnings for when the Synthetic Server has a busy percentage of 80% and issue critical alerts when that busy percentage reaches 90%. The busy percentage is evaluated over the last 30 minutes.

Understanding the Busy Percentage

Each Synthetic Agent can only run one job at a time. When running a job, the Synthetic Agent is busy, and when it's not running, the Synthetic Agent is not busy. The busy percentage indicates the percentage of time that a Synthetic Agent is running jobs. For example, if a Synthetic Agent ran a job that took five minutes and no other jobs, then over the last 10 minutes, it was 50% busy. The busy percentage is based on a metric reported every minute and calculated using pages per minute (PPM). The busy percentage can be used to monitor one Synthetic Agent, a group of Synthetic Agents, or a location.

Create the Dashboards and Health Rules

Once you have verified that the instrumentation was successful and that business applications were created:

  1. Log in to the machine hosting your Synthetic Server.
  2. Change to the Synthetic Server home.

  3. Run the following command to create the preset dashboards and health rules:

    unix/post_deploy.sh
    BASH

  4. From the Controller UI, navigate to the Dashboards & Reports page.

  5. You should see the dashboard Synthetic Private Agent Capacity Monitoring as shown here:

  6. Open the business application for the on-premises Synthetic Server.
  7. Navigate to Alert & Respond > Health Rules.
  8. From Alert & Respond > Health Rules, you will see the health rules that you created in Create Preset Dashboards and Health Rules.

Create Custom Dashboards and Health Rules

The Java Agent will report metrics generated by Synthetic Server such as CPU usage, memory consumption, garbage collection, etc. You can use these metrics to create health rules and custom dashboards.

See the following pages for instructions: