Yandex Cloud
  • Services
  • Solutions
  • Why Yandex Cloud
  • Blog
  • Pricing
  • Documentation
  • Contact us
Get started
Language / Region
Yandex project
© 2023 Yandex.Cloud LLC
Yandex Monitoring
  • Getting started
  • Step-by-step instructions
    • All instructions
    • Working with metrics
      • Delivering Linux system metrics
      • Delivering custom application metrics
      • Delivering metrics from HAProxy and other third-party applications
      • Delivering metrics from hosts outside Yandex Cloud
      • Writing custom metrics via the API
      • Getting a list of metrics
      • Downloading metrics
      • Exporting metrics in Prometheus format
    • Working with dashboards
      • Creating dashboards
      • Copying dashboards
      • Adding widgets to a dashboard
      • Deleting widgets from a dashboard
      • Deleting dashboards
      • Examples of working with the gRPC API
    • Working with alerts
      • Creating alerts
      • Creating notification channels
      • Deleting alerts
  • Concepts
    • Service overview
    • Data model
    • Visualization
      • Overview
      • Query string
      • Widgets
      • Dashboards
    • Transmitting metrics
      • Agent for delivering metrics
        • Overview
        • Installation and startup
        • Configuration
        • Best practices for using the agent
    • Query language
    • Alerting
    • Data decimation
    • Deleting expired metrics (TTL)
    • Quotas and limits
  • Access management
  • Pricing policy
    • Current pricing policy
    • Archive
      • Policy before October 1, 2020
  • API reference
    • Authentication in the API
    • REST
      • Overview
      • MetricsData
        • Overview
        • read
        • write
        • prometheusMetrics
      • MetricsMeta
        • Overview
        • listLabelKeys
        • listLabelValues
        • listMetricNames
        • listMetrics
    • gRPC
      • Overview
      • DashboardService
  • Metric reference
  • Questions and answers
    • General questions
    • Navigation
    • Metric collection and export
    • Metrics and units of measure
    • Alerts / notifications
    • All questions on one page
  1. Step-by-step instructions
  2. Working with metrics
  3. Delivering custom application metrics

Delivering custom application metrics

Written by
Yandex Cloud
  • Example of delivering custom application metrics

Yandex Unified Agent collects metrics in Prometheus format and converts them to Yandex Monitoring format. Using Unified Agent lets you pull metrics from applications that deliver them in the Prometheus format.

To deliver custom application metrics to Yandex Monitoring, use the metrics_pull input that regularly polls an application over HTTP expecting to receive metrics in Prometheus format.

As an example, let's discuss delivery of metrics from a test application written in Python.

Example of delivering custom application metrics

You can also use this method to deliver metrics from any custom applications that use Prometheus client libraries.

  1. Run a test Python application that provides metrics in Prometheus format.

    1. Install the prometheus_client Python library by running the following commands:

      sudo apt install python3-pip
      pip3 install prometheus_client
      
    2. Create a test Python application by writing the following code to the example.py file:

      example.py:

      from prometheus_client import start_http_server, Summary
      import random
      import time
      
      # Create a metric to track the number of requests and their execution time.
      REQUEST_TIME = Summary('request_processing_seconds', 'Time spent processing request')
      
      # Add the metric to the request processing function.
      @REQUEST_TIME.time()
      def process_request(t):
          """A dummy function that takes some time."""
          time.sleep(t)
      
      if __name__ == '__main__':
          # Start the HTTP server so that the application provides metrics.
          start_http_server(8000)
          # Generate random requests.
          while True:
              process_request(random.random())
      
    3. Run the test Python application with the command:

      python3 example.py
      
    4. Check that the application provides metrics by running the curl http://localhost:8000 command. Sample command output:

      curl http://localhost:8000
      # HELP python_gc_objects_collected_total Objects collected during gc
      # TYPE python_gc_objects_collected_total counter
      python_gc_objects_collected_total{generation="0"} 362.0
      python_gc_objects_collected_total{generation="1"} 0.0
      python_gc_objects_collected_total{generation="2"} 0.0
      # HELP python_gc_objects_uncollectable_total Uncollectable object found during GC
      # TYPE python_gc_objects_uncollectable_total counter
      ...
      
  2. Set up a service account from which metrics will be written to Yandex Monitoring.

    1. Create a service account in the folder you want to write metrics to and assign it the monitoring.editor role.

    2. Link your service account to a virtual machine with Unified Agent installed.

  3. Install and configure Yandex Unified Agent.

    1. Create a file named config.yml in your home folder.

      config.yml:

       status:
         port: "16241"
      
       storages:
         - name: main
           plugin: fs
           config:
             directory: /var/lib/yandex/unified_agent/main
             max_partition_size: 100mb
             max_segment_size: 10mb
      
       channels:
         - name: cloud_monitoring
           channel:
             pipe:
               - storage_ref:
                   name: main
             output:
               plugin: yc_metrics
               config:
                 folder_id: "$FOLDER_ID"
                 iam:
                   cloud_meta: {}
      
       routes:
         - input:
             plugin: metrics_pull
             config:
               url: http://localhost:8000
               format:
                 prometheus: {}
               namespace: app
           channel:
             channel_ref:
               name: cloud_monitoring
      
         - input:
             plugin: agent_metrics
             config:
               namespace: ua
           channel:
             pipe:
               - filter:
                   plugin: filter_metrics
                   config:
                     match: "{scope=health}"
             channel_ref:
               name: cloud_monitoring
      
       import:
         - /etc/yandex/unified_agent/conf.d/*.yml
      

      Where $FOLDER_ID is the ID of the folder you want to write metrics.

    2. Install Unified Agent on your VM by running the following command in the home folder:

      docker run \
      -p 16241:16241 -it --detach --uts=host \
      --name=ua \
      -v /proc:/ua_proc \
      -v `pwd`/config.yml:/etc/yandex/unified_agent/config.yml \
      -e PROC_DIRECTORY=/ua_proc \
      -e FOLDER_ID=a1bs... \
      cr.yandex/yc/unified-agent
      

      You can find more ways to install the agent in Installing and running Yandex Unified Agent.

  4. Make sure the metrics are delivered to Yandex Monitoring.

    1. On the home page Yandex Monitoring, go to Metric Explorer.

    2. In the query block, select:

    • The folder where metrics are collected.
    • The label value service=custom.
    • The metric name starting with the app prefix.

What's next

  • Review Unified Agent concepts
  • Learn more about configuring Unified Agent
  • Read the Unified Agent operating instructions

Was the article helpful?

Language / Region
Yandex project
© 2023 Yandex.Cloud LLC