Instana
Instana is an observability platform that delivers automated Application Performance Monitoring (APM), used for website, infrastructure, and application monitoring.
Scope of support
Currently, the Nobl9 integration with Instana does not support monitoring website metrics and ratio metrics for application metrics.
Authentication
Instana uses an API token for authorization. When setting up the Nobl9 Agent or Direct connection to your Instana instance, you need to provide an API token.
You can get your Instana API token in two ways:
By entering the following URL in your browser:
https://${BASE_URL}/#/config/team/accessControl/apiTokens
where the
${BASE_URL}
is the URL that points to your Instana instance, for example:- for SaaS,
https://instance-example.instana.io
- for self-hosted solutions,
http://instana-service:9000
- for SaaS,
In the Instana UI, by selecting Settings > Team Settings > Access Control > API Tokens > Add API Token
For more information on authentication, refer to the Instana API | Instana Documentation.
Do not add any additional permissions to the API token. Metrics fetching works well with a clean API token.
Adding Instana as a Data Source in the Nobl9 UI
To add Instana as a data source in Nobl9 using the Agent or Direct connection method, follow these steps:
- Navigate to Integrations > Sources.
- Click the
button.
- Click the relevant Source icon.
- Choose a relevant connection method (Agent or Direct), then configure the source as described below.
Instana Direct
Direct Configuration in the UI
A Direct connection to Instana requires users to enter their credentials, which Nobl9 stores safely. To set up this type of connection:
Add the URL to connect to your data source (mandatory).
Provide the base URL that points to your Instana instance. For more details, refer to the Authentication section above.Enter your Instana API Token (mandatory).
To use Instana web REST API, you need to create an API token. For more details, refer to the Authentication section above.
- Select a Project.
Specifying a Project is helpful when multiple users are spread across multiple teams or projects. When the Project field is left blank then object is assigned to projectdefault
. - Enter a Display Name.
You can enter a friendly name with spaces in this field. - Enter a Name.
The name is mandatory and can only contain lowercase, alphanumeric characters and dashes (for example,my-project-name
). This field is populated automatically when you enter a display name, but you can edit the result. - Enter a Description.
Here you can add details such as who is responsible for the integration (team/owner) and the purpose of creating it. - Click the Add Data Source
Instana Agent
Agent Configuration in the UI
Follow the instructions below to set up an Agent connection. Refer to the section above for the descriptions of the fields.
- Add the URL to connect to your data source (mandatory).
- Enter a Project.
- Enter a Display Name.
- Enter a Name.
- Create a Description.
- Click the Add Data Source
Agent Using CLI - YAML
The YAML for setting up an Agent connection to Instana looks like this:
apiVersion: n9/v1alpha
kind: Agent
metadata:
name: instana-agent
displayName: Instana Agent # optional
project: default
spec:
description: Agent settings for instana datasource # optional
sourceOf:
- Metrics
- Services
instana:
url: https://instance-example.instana.io
Important notes:
url
- base URL that points to your Instana instance. For more details, refer to the Authentication section above.
You can deploy only one Agent in one YAML file by using the sloctl apply
command.
Deploying the Instana Agent
When you add the data source, Nobl9 automatically generates a Kubernetes configuration and a Docker command line for you to use to deploy the Agent. Both of these are available in the web UI, under the Agent Configuration section. Be sure to swap in your credentials (e.g., replace <INSTANA_API_TOKEN>
with your API token).
- Kubernetes
- Docker
If you use Kubernetes, you can apply the supplied YAML config file to a Kubernetes cluster to deploy the Agent.
# DISCLAIMER: This deployment description contains only the fields necessary for the purpose of this demo.
# It is not a ready-to-apply k8s deployment description, and the client_id and client_secret are only exemplary values.
apiVersion: v1
kind: Secret
metadata:
name: nobl9-agent-dev-instana-myagent
namespace: default
type: Opaque
stringData:
client_id: "Redeemed"
client_secret: "Redeemed"
instana_api_token: "<INSTANA_API_TOKEN>"
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: nobl9-agent-dev-instana-myagent
namespace: default
spec:
replicas: 1
selector:
matchLabels:
nobl9-agent-name: "instana-agent"
nobl9-agent-project: "instana-project"
nobl9-agent-organization: "my-org"
template:
metadata:
labels:
nobl9-agent-name: "instana-agent"
nobl9-agent-project: "instana-project"
nobl9-agent-organization: "my-org"
spec:
containers:
- name: agent-container
image: nobl9/agent:latest
resources:
requests:
memory: "350Mi"
cpu: "0.1"
env:
- name: N9_CLIENT_ID
valueFrom:
secretKeyRef:
key: client_id
name: nobl9-agent-dev-instana-myagent
- name: N9_CLIENT_SECRET
valueFrom:
secretKeyRef:
key: client_secret
name: nobl9-agent-dev-instana-myagent
- name: AUTH_METHOD
value: api_token
- name: API_TOKEN
valueFrom:
secretKeyRef:
key: instana_api_token
name: nobl9-agent-dev-instana-myagent
# The N9_METRICS_PORT is a variable specifying the port to which the /metrics and /health endpoints are exposed.
# The 9090 is the default value and can be changed.
# If you don’t want the metrics to be exposed, comment out or delete the N9_METRICS_PORT variable.
- name: N9_METRICS_PORT
value: "9090"
If you use Docker, you can run the supplied Docker command to deploy the Agent. It will look something like this:
# DISCLAIMER: This Docker command contains only the fields necessary for the purpose of this demo.
# It is not a ready-to-apply command, and you will need to replace the placeholder values with your own values.
docker run -d --restart on-failure \
--name nobl9-agent-dev-instana-myagent \
-e N9_CLIENT_ID="unique_client_id" \
-e N9_CLIENT_SECRET="client_secret" \
# The N9_METRICS_PORT is a variable specifying the port to which the /metrics and /health endpoints are exposed.
# The 9090 is the default value and can be changed.
# If you don’t want the metrics to be exposed, comment out or delete the N9_METRICS_PORT variable.
-e N9_METRICS_PORT=9090 \
-e AUTH_METHOD="api_token" \
-e API_TOKEN="INSTANA_API_TOKEN" \
nobl9/agent: latest
Creating SLOs with Instana
Instana allows you to create SLOs based on:
Infrastructure metrics (for infrastructure components)
Application metrics (for defined applications, discovered services, and endpoints)
Infrastructure metrics can be defined as either Threshold metrics or Ratio metrics, but Application metrics can only be defined as Threshold metrics.
See the instructions in the following sections for more details.
Creating SLO in the UI
- Threshold – Infrastructure
- Threshold – Application
- Ratio – Infrastructure
Follow the instructions below to create an SLO based on a Threshold metric using the Infrastructure type:
- Navigate to Service Level Objectives.
- Click the
button.
- In step 1 of the SLO wizard, select the Service the SLO will be associated with.
- In step 2, select Instana as the Data Source for your SLO, then specify the Metric.
- Select Threshold metric > Infrastructure.
- Enter the Plugin ID (the ID of the plugin available in your monitored system for which you want to retrieve the metric). For more information, refer to the Instana Metrics | Nobl9 Documentation.
- Enter the Metric ID, meaning the ID of the metric you want to retrieve. For more information, refer to the Instana Metrics | Nobl9 Documentation.
- From the Metric Retrieval Method picklist, select a method to obtain the specific metrics with:
- To provide the query, go to Infrastructure > Map in the Instana UI and build the query in the input field, for example,
entity.selfType:zookeeper AND entity.label:replica.1
. - You can get the Snapshot ID from the URL in Instana’s UI by looking for the
snapshotId=[SNAPSHOT_ID]
parameter, for example,GbMUvWHy12TTRsIm3Lko4LDAklw
. - Enter the Query or the Snapshot ID.
- In step 3, define a Time Window for the SLO.
- In step 4, specify the Error Budget Calculation Method and your Objective(s) .
- In step 5, add a Name, Description, and other details about your SLO. You can also select Alert Policies and Labels on this screen.
- When you’ve finished, click Create SLO.
Query, using Dynamic Focus search and filter function:
Snapshot ID, a unique immutable set of metadata, a snapshot:
For more information, refer to the Instana Metrics | Nobl9 Documentation.
Follow the instructions below to create an SLO based on a Threshold metric using the Application type:
- Navigate to Service Level Objectives.
- Click the
button.
- In step 1 of the SLO wizard, select the Service the SLO will be associated with.
- In step 2, select Instana as the Data Source for your SLO, then specify the Metric.
- Select Threshold metric > Application.
- Select the Metric ID you want to use from the following list:
- Calls - to monitor the number of received calls
- Erroneous Calls - to monitor the number of erroneous calls
- Erroneous Calls Rate - to monitor the error rate of received calls
- Latency - to monitor the latency of received calls in milliseconds
- Select the Aggregation. The following list shows the aggregations available for each Metric ID:
- Calls: sum
- Erroneous Calls: sum
- Erroneous Calls Rate: mean
- Latency: sum, mean, max, min, p25, p50, p75, p90, p95, p98, p99
- Enter the API Query. You must create this in the Instana UI and copy and paste it here. There are two methods you can use to specify the query:
- In the Filter field, you can already see a partially defined query. The applied filter must point to the exact entity you want to be observed, for example:
- Any additional manual selections from the left panel in Instana UI will be included in the API query, for example, HTTP Status or Technologies.
- Decide which of the hidden calls you’d like to include - Synthetic or Internal. They are not included in the API query and need to be passed to Nobl9 manually.
- Copy the API query. Make sure you have the toggle Include filter sidebar items on, otherwise, the additional manual selections won’t be included in the API query.
- Select the Group, meaning the single entity you want to be observed. Group by the most specific parameter in the created filter. You can always view the resulting groups below the charts in the Analytics view.
- A combination of filters and group elements must point to a single entity.
- Group by the last logical element in the defined filter. Be as specific as possible.
- The state of the monitored system may change and more than one group can be associated with the previously applied grouping. Therefore, group by entity names as accurately as possible.
- You may have to change the group element accordingly when you change the applied filter.
- Enter the Tag, Tag Entity, and Tag Second Level Key (if applicable). You can get the
Group
details in two ways: - In the Instana UI, look for the
groupBy=(...)
section in the URL. - Parse the deeplink by using the following script and convert it to YAML for the Nobl9
sloctl
: - If you want to include the hidden calls, check the Synthetic or Internal checkbox in the Include Hidden Calls field.
- In step 3, define a Time Window for the SLO.
- In step 4, specify the Error Budget Calculation Method and your Objective(s).
- In step 5, add a Name, Description, and other details about your SLO. You can also select Alert Policies and Labels on this screen.
- When you’ve finished, click Create SLO.
Note that the value in the Aggregation field is selected by default for Calls, Erroneous Calls, and Erroneous Calls Rate Metric ID values.
Method 1:
From the Applications tab, by selecting the Application, Service, or Endpoint you want to observe and clicking the Analyze Calls button.

GET /
endpoints belonging to different services and applications. Likewise, the same service name can appear in various applications.

Method 2:
Go to Analytics, specify the query, and follow the instructions above.
For more information, refer to the Application Analyze | Instana Documentation.
Note that field names vary between the Instana API and the Nobl9 API:
Field name in Instana | Field name in Nobl9 |
---|---|
groupbyTag | tag |
groupbyTagEntity | tagEntity |
groupbyTagSecondLevelKey | tagSecondLevelKey |
#!/bin/bash
echo "$DEEPLINK" |
sed 's/;/\n/g' |
grep groupBy |
sed 's/groupBy=(//' |
sed 's/).*//' |
tr -d '\n' |
awk '
BEGIN {RS = "~"; print "groupBy:"}
{ctr++}
ctr == 1 {key = $0}
ctr == 2 {value = $0; printf " %s: \"%s\"\n", key, value; ctr = 0}' |
sed 's/groupbyT/t/g' |
awk -F':' '
BEGIN {tagEntityExists = 0}
$1 ~ "tagEntity" {tagEntityExists = 1}
{print}
END {
if(tagEntityExists == 0)
{print " tagEntity: \"NOT_APPLICABLE\""}
}'
Follow the instructions below to create an SLO based on a Ratio metric using the Infrastructure type:
- Navigate to Service Level Objectives.
- Click the
button.
- In step 1 of the SLO wizard, select the Service the SLO will be associated with.
- In step 2, select Instana as the Data Source for your SLO, then specify the Metric.
- Select Ratio metric > Infrastructure.
- Choose the Data Count Method.
- For the Non-incremental method, we expect it to be the components of the sum
- For the Incremental method, we expect the value of a metric to be the current sum of some numerator. For more information, refer to the SLO Calculations Guide.
- Enter the Plugin ID for Good and Total metrics (that is, the ID of the plugin available in your monitored system for which you want to retrieve the metric). For more information, refer to the Instana Metrics | Nobl9 Documentation.
- Enter the Metric ID for the the Good and Total metrics (the ID of the metric you want to retrieve). For more information, refer to the Instana Metrics | Nobl9 Documentation.
- From the Metric Retrieval Method picklist, select a method to obtain the specific metrics with:
- Query using Dynamic Focus search and filter function
- Snapshot ID, a unique immutable set of metadata, a snapshot.
- Enter the Query or the Snapshot ID for the Good and Total metrics:
- To provide the query, go to Infrastructure > Map in the Instana UI and build the query in the input field, for example,
entity.selfType:zookeeper AND entity.label:replica.1
. - You can get the Snapshot ID from the URL in Instana’s UI by looking for the
snapshotId=[SNAPSHOT_ID]
parameter, for example,GbMUvWHy12TTRsIm3Lko4LDAklw
. - In step 3, define a Time Window for the SLO.
- In step 4, specify the Error Budget Calculation Method and your Objective(s).
- In step 5, add a Name, Description, and other details about your SLO. You can also select Alert Policies and Labels on this screen.
- When you’ve finished, click Create SLO.
For more information, refer to the Instana Metrics | Nobl9 Documentation.
Note: Ratio metric allows you to combine different Metric Retrieval Methods. For example, you can use Query method for the Good Metric, and Snapshot ID method for the Total Metric.
Instana Metrics
pluginId
Plugins are entities for which metrics are collected. You cannot get the pluginId
from the Instana UI. To fetch the list of available plugins, use the following API request:
curl --request GET \
--url https://${BASE_URL}/api/infrastructure-monitoring/catalog/plugins \
--header "authorization: apiToken ${API_TOKEN}"
This request returns a list of plugins. The plugin
value is the pluginId
while label
is used in the Instana UI as a display name:
[
{
"plugin": "zooKeeper",
"label": "ZooKeeper"
}
]
metricId
The metricId
is the ID of the metric you want to retrieve. You can get the metricId
by using the following API request:
curl --request GET \
--url https://${BASE_URL}/api/infrastructure-monitoring/catalog/metrics/${PLUGIN_ID} \
--header "authorization: apiToken ${API_TOKEN}"
PLUGIN_ID
is the ID of the plugin you want to retrieve the metricId
for. It's the plugin
from the /api/infrastructure-monitoring/catalog/plugins
response.
This request returns a list of all available metrics for this specific plugin, what you are looking for in the response is metricId
. Here's an example:
[
{
"formatter": "UNDEFINED",
"label": "ZooKeepers Max request latency",
"description": "Max request latency",
"metricId": "max_request_latency",
"pluginId": "zooKeeper",
"custom": false
}
]
Currently, Nobl9 only allows you to retrieve one metric at a time.
query
The Query
is built using Instana's Dynamic Focus search and filter function.
Dynamic Focus queries use Lucene query syntax. The query must be constructed in the Instana UI and copied unchanged. For more information, refer to the Dynamic Focus Query | Instana Documentation.
To provide the query, go to Infrastructure > Map in the Instana UI and build the query in the input field, for example, entity.selfType:zookeeper AND entity.label:replica.1
.
Instana does not allow aggregation of infrastructure metrics. Since Nobl9 can only process a single dataset and there is no aggregation on the N9 side, you have to make sure your query is specific and includes, for example, the name of the target cluster, zone, or node.
snapshotId
A snapshot represents static information about an entity as it was at a specific point in time. For more information, refer to the Search Snapshots | Instana API Docs.
You can get the snapshotId
from the URL in Instana's UI by looking for the snapshotId=${SNAPSHOT_ID}
parameter. For example,
for this URL: https://${BASE_URL}/#/physical/dashboard?timeline.ws=1728000000&timeline.to=1642719600000&timeline.fm=1642719600000&timeline.ar=false&snapshotId=GbMUvQHy12TTRsIm3Lko4LDAklw
the snapshotId is GbMUvQHy12TTRsIm3Lko4LDAklw
.
Currently, Nobl9 only allows you to retrieve one snapshotId
at a time.
Changing the metadata may result in changing the snapshot. When a new snapshotId
is generated for the entity you monitor, you must update your SLO. Otherwise, Nobl9 cannot collect any more measurements.
SLOs using Instana - YAML samples
Generic schema with a description of objects and field validations:
apiVersion: n9/v1alpha
kind: SLO
metadata:
name: string
displayName: string # optional
project: string
spec:
description: string # optional
service: [service name] # name of the service you defined in the same project as the SLO
indicator:
metricSource:
name: [datasource name] # name of the data source you defined
project: [project name] # optional if not defined, project is the same as the SLO
rawMetric:
# exactly one of possible source types which depends on selected metricSource for the SLO
instana: # application XOR infrastructure
metricType: oneOf{"application", "infrastructure"} # mandatory
infrastructure:
metricRetrievalMethod: oneOf{"query", "snapshot"} # mandatory
query: "string" # XOR with snapshotId
snapshotId: "string" # XOR with query
metricId: "string" # mandatory
pluginId: "string" # mandatory
application:
metricId: # mandatory, oneOf{"calls", "erroneousCalls", "errors", "latency"}
aggregation: "" # mandatory, value depends on the metricId type. See notes below
groupBy: # mandatory
tag: "" # mandatory
tagEntity: "" # mandatory, oneOf{"DESTINATION", "SOURCE", "NOT_APPLICABLE"}
tagSecondLevelKey: "" # mandatory
apiQuery: "{}" # mandatory, API query user passes in a JSON format. Must be a valid JSON
includeInternal: false # optional, default value is false
includeSynthetic: false # optional, default value is false
Notes:
aggregation
- Depends on the value specified formetricId
:For
calls
anderroneousCalls
: usesum
.For
errors
: usemean
.For
latency
: use one of the valuessum
,mean
,min
,max
,p25
,p50
,p75
,p90
,p95
,p98
,p99
.
rawMetric YAML examples
- rawMetric Application Query
- rawMetric Infrastructure Query
- rawMetric Infrastructure Snapshot
Here’s an example of Instana using rawMetric
(Threshold metric) with metricType=”application”
, and the Query retrieval method:
apiVersion: n9/v1alpha
kind: SLO
metadata:
name: opentsdb-datanode-latency-95th-application-query
project: instana
spec:
service: instana-service
indicator:
metricSource:
name: instana
project: instana
timeWindows:
- unit: Week
count: 1
calendar:
startTime: 2020-01-21 12:30:00 # date with time in 24h format
timeZone: America/New_York # name as in IANA Time Zone Database
budgetingMethod: Occurrences
objectives:
- displayName: Healthy
value: 10
op: lte
rawMetric:
query:
instana:
metricType: "application"
application:
metricId: "latency"
aggregation: "p95"
groupBy:
tag: "endpoint.name"
tagEntity: "DESTINATION"
tagSecondLevelKey: ""
includeInternal: false
includeSynthetic: false
apiQuery: "{}"
target: 0.99
- displayName: Slower
value: 30
op: lte
rawMetric:
query:
instana:
metricType: "application"
application:
metricId: "latency"
aggregation: "p95"
groupBy:
tag: "endpoint.name"
tagEntity: "DESTINATION"
tagSecondLevelKey: ""
includeInternal: false
includeSynthetic: false
apiQuery: "{}"
target: 0.95
- displayName: Critical
value: 100
op: lte
rawMetric:
query:
instana:
metricType: "application"
application:
metricId: "latency"
aggregation: "p95"
groupBy:
tag: "endpoint.name"
tagEntity: "DESTINATION"
tagSecondLevelKey: ""
includeInternal: false
includeSynthetic: false
apiQuery: "{}"
target: 0.95
Here’s an example of Instana using rawMetric
(Threshold metric) with metricType=”infrastructure”
, and the Query retrieval method:
apiVersion: n9/v1alpha
kind: SLO
metadata:
name: zookeeper-outstanding-requests-replica-1-infrastructure-query
project: instana
spec:
description: The number of queued requests in the server. This goes up when the server receives more requests than it can process.
service: instana-service
indicator:
metricSource:
name: instana
project: instana
timeWindows:
- unit: Week
count: 1
calendar:
startTime: 2020-01-21 12:30:00 # date with time in 24h format
timeZone: America/New_York # name as in IANA Time Zone Database
budgetingMethod: Occurrences
objectives:
- displayName: Acceptable
value: 10
op: lte
rawMetric:
query:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "query"
metricId: "metricId"
pluginId: "pluginId"
query: "entity.service.name:zookeeper entity.label:replica.1"
target: 0.9
Here’s an example of Instana using rawMetric
(Threshold metric) with metricType=”infrastructure”
, and the Snapshot ID retrieval method:
apiVersion: n9/v1alpha
kind: SLO
metadata:
name: nodes-availability-infrastructure-snapshot
project: instana
spec:
service: instana-service
indicator:
metricSource:
name: instana
project: instana
timeWindows:
- unit: Week
count: 1
calendar:
startTime: 2020-01-21 12:30:00 # date with time in 24h format
timeZone: America/New_York # name as in IANA Time Zone Database
budgetingMethod: Occurrences
objectives:
- displayName: Healthy
value: 1
op: lt
rawMetric:
query:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "snapshot"
metricId: "metricId"
pluginId: "pluginId"
snapshotId: "snapshotId"
target: 0.99
countMetric YAML examples
- countMetric Infrastructure
- countMetric Infrastructure Query
- countMetric Infrastructure Snapshot
Here’s an example of Instana using countMetric
(Ratio metric) with metricType=”infrastructure”
:
apiVersion: n9/v1alpha
kind: SLO
metadata:
name: slo-with-instana-agent-count-metrics-with-infrastructure
displayName: Slo with Instana agent count metrics with infrastructure
spec:
description: Description
service: webapp-service
indicator:
metricSource:
name: instana
timeWindows:
- unit: Week
count: 1
calendar:
startTime: 2020-01-21 12:30:00 # date with time in 24h format
timeZone: America/New_York # name as in IANA Time Zone Database
budgetingMethod: Occurrences
objectives:
- displayName: Good
value: 7.5
target: 0.9
countMetrics:
incremental: false
good:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "query"
query: "queryGood"
metricId: "metricId"
pluginId: "pluginId"
total:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "snapshot"
snapshotId: "snapshotId"
metricId: "metricId"
pluginId: "pluginId"
Here’s an example of Instana using countMetric
(Ratio metric) with metricType=”infrastructure”
, and the Query retrieval method:
apiVersion: n9/v1alpha
kind: SLO
metadata:
name: opentsdb-replicas-availability-infrastructure-query
project: instana
spec:
service: instana-service
indicator:
metricSource:
name: instana
project: instana
timeWindows:
- unit: Week
count: 1
calendar:
startTime: 2020-01-21 12:30:00 # date with time in 24h format
timeZone: America/New_York # name as in IANA Time Zone Database
budgetingMethod: Occurrences
objectives:
- displayName: Acceptable
value: 0.95
target: 0.9
countMetrics:
incremental: false
good:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "query"
metricId: "metricId"
pluginId: "pluginId"
query: "queryGood"
total:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "query"
metricId: "metricId"
pluginId: "pluginId"
query: "queryGood"
Here’s an example of Instana using countMetric
(Ratio metric) with metricType=”infrastructure”
, and the Snapshot ID retrieval method:
apiVersion: n9/v1alpha
kind: SLO
metadata:
name: dev-tooling-all-replicas-availability-infrastructure-snapshot
project: instana
spec:
service: instana-service
indicator:
metricSource:
name: instana
project: instana
timeWindows:
- unit: Week
count: 1
calendar:
startTime: 2020-01-21 12:30:00 # date with time in 24h format
timeZone: America/New_York # name as in IANA Time Zone Database
budgetingMethod: Occurrences
objectives:
- displayName: Acceptable
value: 0.95
target: 0.9
countMetrics:
incremental: false
good:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "snapshot"
metricId: "metricId"
pluginId: "pluginId"
snapshotId: "snapshotId"
total:
instana:
metricType: "infrastructure"
infrastructure:
metricRetrievalMethod: "snapshot"
metricId: "metricId"
pluginId: "pluginId"
snapshotId: "snapshotId"
API Query Example
Here's an example API query for a Threshold > Application metric:
{
"type":"EXPRESSION",
"logicalOperator":"AND",
"elements": [
{
"type":"TAG_FILTER",
"name":"call.inbound_of_application",
"operator":"EQUALS",
"entity":"NOT_APPLICABLE",
"value":"All Services"
},
{
"type":"TAG_FILTER",
"name":"service.name",
"operator":"EQUALS",
"entity":"DESTINATION",
"value":"datanode"
},
{
"type":"TAG_FILTER",
"name":"endpoint.name",
"operator":"EQUALS",
"entity":"DESTINATION",
"value":"GET /"
}
]
}
Querying the Instana Server
Nobl9 queries the Instana server on a per-minute basis. This allows Nobl9 to collect up to 1 data point per minute.
Instana API Rate Limits
The following rate limits apply to the Instana API:
- Up to 5000 calls per hour can be made. For more information, refer to the Rate Limits | Instana Documentation.
Useful Links
Agent REST API | Instana Documentation
Web REST API | Instana Documentation
Infrastructure Metrics | Instana Documentation
Application Analyze | Instana Documentation
Dynamic Focus Query | Instana Documentation
IBM Observability | Instana Documentation
Rate Limits | Instana Documentation
Agent Metrics | Nobl9 Documentation
Creating SLOs via Terraform | Nobl9 Terraform Documentation
Creating Agents via Terraform | Nobl9 Terraform Documentation