Plugin automatic test framework

Plugin test framework is designed for verifying the plugins' function and compatible status. As there are dozens of plugins and hundreds of versions need to be verified, it is impossible to do manually. The test framework uses container based tech stack, requires a set of real services with agent installed, then the test mock OAP backend is running to check the segments data sent from agents.

Every plugin maintained in the main repo requires corresponding test cases, also matching the versions in the supported list doc.

Environment Requirements

MacOS/Linux
JDK 8+
Docker
Docker Compose

Case Base Image Introduction

The test framework provides JVM-container and Tomcat-container base images including JDK8, JDK14. You could choose the suitable one for your test case, if both are suitable, JVM-container is preferred.

JVM-container Image Introduction

JVM-container uses openjdk:8 as the base image. JVM-container has supported JDK14, which inherits openjdk:14. The test case project is required to be packaged as project-name.zip, including startup.sh and uber jar, by using mvn clean package.

Take the following test projects as good examples

sofarpc-scenario as a single project case.
webflux-scenario as a case including multiple projects.
jdk14-with-gson-scenario as a single project case with JDK14.

Tomcat-container Image Introduction

Tomcat-container uses tomcat:8.5.57-jdk8-openjdk or tomcat:8.5.57-jdk14-openjdk as the base image. The test case project is required to be packaged as project-name.war by using mvn package.

Take the following test project as a good example

spring-4.3.x-scenario

Test project hierarchical structure

The test case is an independent maven project, and it is required to be packaged as a war tar ball or zip file, depends on the chosen base image. Also, two external accessible endpoints, mostly two URLs, are required.

All test case codes should be in org.apache.skywalking.apm.testcase.* package, unless there are some codes expected being instrumented, then the classes could be in test.org.apache.skywalking.apm.testcase.* package.

JVM-container test project hierarchical structure

[plugin-scenario]
    |- [bin]
        |- startup.sh
    |- [config]
        |- expectedData.yaml
    |- [src]
        |- [main]
            |- ...
        |- [resource]
            |- log4j2.xml
    |- pom.xml
    |- configuration.yaml
    |- support-version.list

[] = directory

Tomcat-container test project hierarchical structure

[plugin-scenario]
    |- [config]
        |- expectedData.yaml
    |- [src]
        |- [main]
            |- ...
        |- [resource]
            |- log4j2.xml
        |- [webapp]
            |- [WEB-INF]
                |- web.xml
    |- pom.xml
    |- configuration.yaml
    |- support-version.list

[] = directory

Test case configuration files

The following files are required in every test case.

File Name	Descriptions
`configuration.yml`	Declare the basic case inform, including, case name, entrance endpoints, mode, dependencies.
`expectedData.yaml`	Describe the expected segmentItems.
`support-version.list`	List the target versions for this case
`startup.sh`	`JVM-container` only, don't need this when use`Tomcat-container`

* support-version.list format requires every line for a single version(Contains only the last version number of each minor version). Could use # to comment out this version.

configuration.yml

Field	description
type	Image type, options, `jvm` or `tomcat`. Required.
entryService	The entrance endpoint(URL) for test case access. Required. (HTTP Method: GET)
healthCheck	The health check endpoint(URL) for test case access. Required. (HTTP Method: HEAD)
startScript	Path of start up script. Required in `type: jvm` only.
framework	Case name.
runningMode	Running mode whether with the optional plugin, options, `default`(default), `with_optional`, `with_bootstrap`
withPlugins	Plugin selector rule. eg:`apm-spring-annotation-plugin-*.jar`. Required when `runningMode=with_optional` or `runningMode=with_bootstrap`.
environment	Same as `docker-compose#environment`.
depends_on	Same as `docker-compose#depends_on`.
dependencies	Same as `docker-compose#services`, `image、links、hostname、environment、depends_on` are supported.

Notice:, docker-compose active only when dependencies is only blank.

runningMode option description.

Option	description
default	Active all plugins in `plugin` folder like the official distribution agent.
with_optional	Active `default` and plugins in `optional-plugin` by the give selector.
with_bootstrap	Active `default` and plugins in `bootstrap-plugin` by the give selector.

with_optional/with_bootstrap supports multiple selectors, separated by ;.

File Format

type:
entryService:
healthCheck:
startScript:
framework:
runningMode:
withPlugins:
environment:
  ...
depends_on:
  ...
dependencies:
  service1:
    image:
    hostname: 
    expose:
      ...
    environment:
      ...
    depends_on:
      ...
    links:
      ...
    entrypoint:
      ...
    healthcheck:
      ...

dependencies supports docker compose healthcheck. But the format is a little difference. We need - as the start of every config item, and describe it as a string line.

Such as in official doc, the health check is

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"]
  interval: 1m30s
  timeout: 10s
  retries: 3
  start_period: 40s

The here, you should write as

healthcheck:
  - 'test: ["CMD", "curl", "-f", "http://localhost"]'
  - "interval: 1m30s"
  - "timeout: 10s"
  - "retries: 3"
  - "start_period: 40s"

In some cases, the dependency service, mostly 3rd party server like SolrJ server, is required to keep the same version as client lib version, which defined as ${test.framework.version} in pom. Could use ${CASE_SERVER_IMAGE_VERSION} as the version number, it will be changed in the test for every version.

Don‘t support resource related configurations, such as volumes, ports and ulimits. Because in test scenarios, don’t need mapping any port to the host VM, or mount any folder.

Take following test cases as examples

expectedData.yaml

Operator for number

Operator	Description
`nq`	Not equal
`eq`	Equal(default)
`ge`	Greater than or equal
`gt`	Greater than

Operator for String

Operator	Description
`not null`	Not null
`null`	Null or empty String
`eq`	Equal(default)

Expected Data Format Of The Segment

segmentItems:
-
  serviceName: SERVICE_NAME(string)
  segmentSize: SEGMENT_SIZE(int)
  segments:
  - segmentId: SEGMENT_ID(string)
    spans:
        ...

Field	Description
serviceName	Service Name.
segmentSize	The number of segments is expected.
segmentId	trace ID.
spans	segment span list. Follow the next section to see how to describe every span.

Expected Data Format Of The Span

Notice: The order of span list should follow the order of the span finish time.

    operationName: OPERATION_NAME(string)
    parentSpanId: PARENT_SPAN_ID(int)
    spanId: SPAN_ID(int)
    startTime: START_TIME(int)
    endTime: END_TIME(int)
    isError: IS_ERROR(string: true, false)
    spanLayer: SPAN_LAYER(string: DB, RPC_FRAMEWORK, HTTP, MQ, CACHE)
    spanType: SPAN_TYPE(string: Exit, Entry, Local)
    componentId: COMPONENT_ID(int)
    tags:
    - {key: TAG_KEY(string), value: TAG_VALUE(string)}
    ...
    logs:
    - {key: LOG_KEY(string), value: LOG_VALUE(string)}
    ...
    peer: PEER(string)
    refs:
    - {
       traceId: TRACE_ID(string),
       parentTraceSegmentId: PARENT_TRACE_SEGMENT_ID(string),
       parentSpanId: PARENT_SPAN_ID(int),
       parentService: PARENT_SERVICE(string),
       parentServiceInstance: PARENT_SERVICE_INSTANCE(string),
       parentEndpoint: PARENT_ENDPOINT_NAME(string),
       networkAddress: NETWORK_ADDRESS(string),
       refType:  REF_TYPE(string: CrossProcess, CrossThread)
     }
   ...

Field	Description
operationName	Span Operation Name.
parentSpanId	Parent span id. Notice: The parent span id of the first span should be -1.
spanId	Span Id. Notice, start from 0.
startTime	Span start time. It is impossible to get the accurate time, not 0 should be enough.
endTime	Span finish time. It is impossible to get the accurate time, not 0 should be enough.
isError	Span status, true or false.
componentId	Component id for your plugin.
tags	Span tag list. Notice, Keep in the same order as the plugin coded.
logs	Span log list. Notice, Keep in the same order as the plugin coded.
SpanLayer	Options, DB, RPC_FRAMEWORK, HTTP, MQ, CACHE.
SpanType	Span type, options, Exit, Entry or Local.
peer	Remote network address, IP + port mostly. For exit span, this should be required.

The verify description for SegmentRef

Field	Description
traceId
parentTraceSegmentId	Parent SegmentId, pointing to the segment id in the parent segment.
parentSpanId	Parent SpanID, pointing to the span id in the parent segment.
parentService	The service of parent/downstream service name.
parentServiceInstance	The instance of parent/downstream service instance name.
parentEndpoint	The endpoint of parent/downstream service.
networkAddress	The peer value of parent exit span.
refType	Ref type, options, CrossProcess or CrossThread.

Expected Data Format Of The Meter Items

meterItems:
-
  serviceName: SERVICE_NAME(string)
  meterSize: METER_SIZE(int)
  meters:
  - ...

Field	Description
serviceName	Service Name.
meterSize	The number of meters is expected.
meters	meter list. Follow the next section to see how to describe every meter.

Expected Data Format Of The Meter

    meterId: 
        name: NAME(string)
        tags:
        - {name: TAG_NAME(string), value: TAG_VALUE(string)}
    singleValue: SINGLE_VALUE(double)
    histogramBuckets:
    - HISTOGRAM_BUCKET(double)
    ...

The verify description for MeterId

Field	Description
name	meter name.
tags	meter tags.
tags.name	tag name.
tags.value	tag value.
singleValue	counter or gauge value. Using condition operate of the number to validate, such as `gt`, `ge`. If current meter is histogram, don't need to write this field.
histogramBuckets	histogram bucket. The bucket list must be ordered. The tool assert at least one bucket of the histogram having nonzero count. If current meter is counter or gauge, don't need to write this field.

startup.sh

This script provide a start point to JVM based service, most of them starts by a java -jar, with some variables. The following system environment variables are available in the shell.

Variable	Description
agent_opts	Agent plugin opts, check the detail in plugin doc or the same opt added in this PR.
SCENARIO_NAME	Service name. Default same as the case folder name
SCENARIO_VERSION	Version
SCENARIO_ENTRY_SERVICE	Entrance URL to access this service
SCENARIO_HEALTH_CHECK_URL	Health check URL

${agent_opts} is required to add into your java -jar command, which including the parameter injected by test framework, and make agent installed. All other parameters should be added after ${agent_opts}.

The test framework will set the service name as the test case folder name by default, but in some cases, there are more than one test projects are required to run in different service codes, could set it explicitly like the following example.

Example

home="$(cd "$(dirname $0)"; pwd)"

java -jar ${agent_opts} "-Dskywalking.agent.service_name=jettyserver-scenario" ${home}/../libs/jettyserver-scenario.jar &
sleep 1

java -jar ${agent_opts} "-Dskywalking.agent.service_name=jettyclient-scenario"  ${home}/../libs/jettyclient-scenario.jar &

Only set this or use other skywalking options when it is really necessary.

Take the following test cases as examples

Best Practices

How To Use The Archetype To Create A Test Case Project

We provided archetypes and a script to make creating a project easier. It creates a completed project of a test case. So that we only need to focus on cases. First, we can use followed command to get usage about the script.

bash ${SKYWALKING_HOME}/test/plugin/generator.sh

Then, runs and generates a project, named by scenario_name, in ./scenarios.

Recommendations for pom

    <properties>
        <!-- Provide and use this property in the pom. -->
        <!-- This version should match the library version, -->
        <!-- in this case, http components lib version 4.3. -->
        <test.framework.version>4.3</test.framework.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>${test.framework.version}</version>
        </dependency>
        ...
    </dependencies>

    <build>
        <!-- Set the package final name as same as the test case folder case. -->
        <finalName>httpclient-4.3.x-scenario</finalName>
        ....
    </build>

How To Implement Heartbeat Service

Heartbeat service is designed for checking the service available status. This service is a simple HTTP service, returning 200 means the target service is ready. Then the traffic generator will access the entry service and verify the expected data. User should consider to use this service to detect such as whether the dependent services are ready, especially when dependent services are database or cluster.

Notice, because heartbeat service could be traced fully or partially, so, segmentSize in expectedData.yaml should use ge as the operator, and don't include the segments of heartbeat service in the expected segment data.

The example Process of Writing Tracing Expected Data

Expected data file, expectedData.yaml, include SegmentItems part.

We are using the HttpClient plugin to show how to write the expected data.

There are two key points of testing

Whether is HttpClient span created.
Whether the ContextCarrier created correctly, and propagates across processes.

+-------------+         +------------------+            +-------------------------+
|   Browser   |         |  Case Servlet    |            | ContextPropagateServlet |
|             |         |                  |            |                         |
+-----|-------+         +---------|--------+            +------------|------------+
      |                           |                                  |
      |                           |                                  |
      |       WebHttp            +-+                                 |
      +------------------------> |-|         HttpClient             +-+
      |                          |--------------------------------> |-|
      |                          |-|                                |-|
      |                          |-|                                |-|
      |                          |-| <--------------------------------|
      |                          |-|                                +-+
      | <--------------------------|                                 |
      |                          +-+                                 |
      |                           |                                  |
      |                           |                                  |
      |                           |                                  |
      |                           |                                  |
      +                           +                                  +

segmentItems

By following the flow of HttpClient case, there should be two segments created.

Segment represents the CaseServlet access. Let's name it as SegmentA.
Segment represents the ContextPropagateServlet access. Let's name it as SegmentB.

segmentItems:
  - serviceName: httpclient-case
    segmentSize: ge 2 # Could have more than one health check segments, because, the dependency is not standby.

Because Tomcat plugin is a default plugin of SkyWalking, so, in SegmentA, there are two spans

Tomcat entry span
HttpClient exit span

SegmentA span list should like following

    - segmentId: not null
      spans:
        - operationName: /httpclient-case/case/context-propagate
          parentSpanId: 0
          spanId: 1
          startTime: nq 0
          endTime: nq 0
          isError: false
          spanLayer: Http
          spanType: Exit
          componentId: eq 2
          tags:
            - {key: url, value: 'http://127.0.0.1:8080/httpclient-case/case/context-propagate'}
            - {key: http.method, value: GET}
          logs: []
          peer: 127.0.0.1:8080
        - operationName: /httpclient-case/case/httpclient
          parentSpanId: -1
          spanId: 0
          startTime: nq 0
          endTime: nq 0
          spanLayer: Http
          isError: false
          spanType: Entry
          componentId: 1
          tags:
            - {key: url, value: 'http://localhost:{SERVER_OUTPUT_PORT}/httpclient-case/case/httpclient'}
            - {key: http.method, value: GET}
          logs: []
          peer: null

SegmentB should only have one Tomcat entry span, but includes the Ref pointing to SegmentA.

SegmentB span list should like following

- segmentId: not null
  spans:
  -
   operationName: /httpclient-case/case/context-propagate
   parentSpanId: -1
   spanId: 0
   tags:
   - {key: url, value: 'http://127.0.0.1:8080/httpclient-case/case/context-propagate'}
   - {key: http.method, value: GET}
   logs: []
   startTime: nq 0
   endTime: nq 0
   spanLayer: Http
   isError: false
   spanType: Entry
   componentId: 1
   peer: null
   refs:
    - {parentEndpoint: /httpclient-case/case/httpclient, networkAddress: 'localhost:8080', refType: CrossProcess, parentSpanId: 1, parentTraceSegmentId: not null, parentServiceInstance: not null, parentService: not null, traceId: not null}

The example Process of Writing Meter Expected Data

Expected data file, expectedData.yaml, include MeterItems part.

We are using the toolkit plugin to demonstrate how to write the expected data. When write the meter plugin, the expected data file keeps the same.

There is one key point of testing

Build a meter and operate it.

Such as Counter:

MeterFactory.counter("test_counter").tag("ck1", "cv1").build().increment(1d);
MeterFactory.histogram("test_histogram").tag("hk1", "hv1").steps(1d, 5d, 10d).build().addValue(2d);

+-------------+         +------------------+
|   Plugin    |         |    Agent core    |
|             |         |                  |
+-----|-------+         +---------|--------+
      |                           |         
      |                           |         
      |    Build or operate      +-+        
      +------------------------> |-|        
      |                          |-]
      |                          |-|        
      |                          |-|        
      |                          |-|
      |                          |-|        
      | <--------------------------|        
      |                          +-+        
      |                           |         
      |                           |         
      |                           |         
      |                           |         
      +                           +

meterItems

By following the flow of the toolkit case, there should be two meters created.

Meter test_counter created from MeterFactory#counter. Let's name it as MeterA.
Meter test_histogram created from MeterFactory#histogram. Let's name it as MeterB.

meterItems:
  - serviceName: toolkit-case
    meterSize: 2

They're showing two kinds of meter, MeterA has a single value, MeterB has a histogram value.

MeterA should like following, counter and gauge use the same data format.

- meterId:
    name: test_counter
    tags:
      - {name: ck1, value: cv1}
  singleValue: gt 0

MeterB should like following.

- meterId:
    name: test_histogram
    tags:
      - {name: hk1, value: hv1}
  histogramBuckets:
    - 0.0
    - 1.0
    - 5.0
    - 10.0

Local Test and Pull Request To The Upstream

First of all, the test case project could be compiled successfully, with right project structure and be able to deploy. The developer should test the start script could run in Linux/MacOS, and entryService/health services are able to provide the response.

You could run test by using following commands

cd ${SKYWALKING_HOME}
bash ./test/plugin/run.sh -f ${scenario_name}

Notice，if codes in ./apm-sniffer have been changed, no matter because your change or git update， please recompile the skywalking-agent. Because the test framework will use the existing skywalking-agent folder, rather than recompiling it every time.

Use ${SKYWALKING_HOME}/test/plugin/run.sh -h to know more command options.

If the local test passed, then you could add it to .github/workflows/plugins-test.<n>.yaml file, which will drive the tests running on the GitHub Actions of official SkyWalking repository. Based on your plugin's name, please add the test case into file .github/workflows/plugins-test.<n>.yaml, by alphabetical orders.

Every test case is a GitHub Actions Job. Please use the scenario directory name as the case name, mostly you'll just need to decide which file (plugins-test.<n>.yaml) to add your test case, and simply put one line (as follows) in it, take the existed cases as examples. You can run python3 tools/select-group.py to see which file contains the least cases and add your cases into it, in order to balance the running time of each group.

If a test case required to run in JDK 14 environment, please add you test case into file plugins-jdk14-test.<n>.yaml.

jobs:
  PluginsTest:
    name: Plugin
    runs-on: ubuntu-18.04
    timeout-minutes: 90
    strategy:
      fail-fast: true
      matrix:
        case:
          # ...
          - <your scenario test directory name>
          # ...