All Products
Document Center

Application Real-Time Monitoring Service:Use OpenTelemetry to report Swift application data

Last Updated:Nov 21, 2023

Before you can view the trace data of your application in the Managed Service for OpenTelemetry console, you must report the trace data to Managed Service for OpenTelemetry. This topic describes how to instrument a Swift application and report the trace data of the Swift application.


To obtain an endpoint of OpenTelemetry, perform the following steps:

  1. Log on to the Managed Service for OpenTelemetry console.

  2. In the left-side navigation pane, click Cluster Configurations. Then, click the Access point information tab.

  3. In the top navigation bar, select a region. In the Cluster Information section, turn on Show Token.

  4. In the Client section, click OpenTelemetry.

    Obtain an endpoint of OpenTelemetry in the Related Information column of the table in the lower part. OT接入点信息


    If your application is deployed in an Alibaba Cloud production environment, use a Virtual Private Cloud (VPC) endpoint. Otherwise, use a public endpoint.

Sample code

In this example, OpenTelemetry is used to report the trace data of a macOS command-line application written in Swift. The method used in this example also applies to iOS applications.

Download the sample code from opentelemetry-swift-demo.

Step 1: Create an application and add dependencies

  1. Select the type of the application that you want to create. For example, choose macOS > Command Line Tool.

    Command Line Tool

  2. In XCode, choose File > Add Packages..., enter in the search box, and then select version 1.4.1.


    For more information about versions, visit the opentelemetry-swift page on GitHub.


  3. Select the required packages.

    The following figure shows the packages that are used in this example.Package Products

Step 2: Initialize OpenTelemetry

  1. Create an exporter to export monitoring data.

    Select one of the following methods to report trace data:

    • Method 1: Report trace data by using the gRPC protocol

      • Replace <gRPC-endpoint> and <gRPC-port> with the endpoint and port number obtained in Prerequisites. In this example, host: "", port:8090 is used.

      • Replace <your-token> with the authentication token obtained in Prerequisites.

      let grpcChannel = ClientConnection(
          configuration: ClientConnection.Configuration.default(
              target: .hostAndPort("<gRPC-endpoint>", 8090), // Specify the endpoint that does not contain the http:// prefix. In this example, is used.
              eventLoopGroup: MultiThreadedEventLoopGroup(numberOfThreads: 1)
      let otlpGrpcConfiguration = OtlpConfiguration(
          timeout: OtlpConfiguration.DefaultTimeoutInterval,
          headers: [
      let otlpGrpcTraceExporter = OtlpTraceExporter(channel: grpcChannel, config: otlpGrpcConfiguration)
    • Method 2: Report trace data by using the HTTP protocol

      Replace <HTTP-endpoint> with the endpoint obtained in Prerequisites. In this example, is used.

      let url = URL(string: "<HTTP-endpoint>")
      let otlpHttpTraceExporter = OtlpHttpTraceExporter(endpoint: url!)
    • Method 3: Obtain trace data in the command line

      let consoleTraceExporter = StdoutExporter(isDebug: true)
  2. Obtain the tracer that is used to create a span.

    • Replace <your-service-name> with the name of the application whose data you want to report and <your-host-name> with the hostname.

    • Replace <trace-exporter> with different values based on the method that you use to report trace data in Step 1.

      • Method 1: Replace <trace-exporter> with otlpGrpcTraceExporter.

      • Method 2: Replace <trace-exporter> with otlpHttpTraceExporter.

      • Method 3: Replace <trace-exporter> with consoleTraceExporter.

    // Specify the application name and the hostname.
    let resource = Resource(attributes: [
        ResourceAttributes.serviceName.rawValue: AttributeValue.string("<your-service-name>"),
        ResourceAttributes.hostName.rawValue: AttributeValue.string("<your-host-name>")
    // Configure the TracerProvider.
    OpenTelemetry.registerTracerProvider(tracerProvider: TracerProviderBuilder()
                                         .add(spanProcessor: BatchSpanProcessor(spanExporter: <trace-exporter>)) // Report data to Managed Service for OpenTelemetry.
                                         .with(resource: resource)
    // Obtain the tracer that is used to create a span.
    let tracer = OpenTelemetry.instance.tracerProvider.get(instrumentationName: "instrumentation-library-name", instrumentationVersion: "1.0.0")

Step 3: Create a span to track trace data

  1. Create a span, configure attributes and an event for the span, and then obtain the trace ID of the span.

    let span = tracer.spanBuilder(spanName: "first span").startSpan()
    // Configure attributes.
    span.setAttribute(key: "http.method", value: "GET")
    span.setAttribute(key: "http.url", value: "")
    let attributes = [
        "key": AttributeValue.string("value"),
    // your code...
    // Configure an event.
    span.addEvent(name: "computation complete", attributes: attributes)
    // Display the trace ID.
    // your code...
    // End the current span.
  2. Create a nested span.

    let parentSpan = tracer.spanBuilder(spanName: "parent span").startSpan()
    // your code...
    let childSpan = tracer.spanBuilder(spanName: "child span").setParent(parentSpan).startSpan()
    // your code...
    // your code...
  3. Start the application.

    Log on to the ARMS console. In the left-side navigation pane, choose Application Monitoring > Applications. On the Applications page, click the name of the application. On the page that appears, view the trace data.


    If the Java图标 icon is displayed in the Language column, the application is connected to Application Monitoring. If a hyphen (-) is displayed, the application is connected to Managed Service for OpenTelemetry.