Not a Supported Metric Type in Oracle Cloud Infrastructure

When working with Oracle Corporation Cloud Infrastructure (OCI), administrators and cloud engineers frequently encounter monitoring and observability errors while configuring alarms, metrics, dashboards, or custom integrations. One common issue is the “Not a Supported Metric Type” error in OCI Monitoring services.

This issue usually appears during:

• Alarm creation
• Monitoring query execution
• OCI Observability setup
• Custom metric integration
• OIC and OCI integrations
• Metrics Explorer usage
• Terraform or API-based monitoring configurations

Understanding why this error occurs is extremely important for OCI administrators, DevOps engineers, monitoring specialists, and cloud consultants managing enterprise Oracle Cloud environments.

In this article, we will explore the root causes, architecture, troubleshooting methods, implementation scenarios, and best practices to resolve the “Not a Supported Metric Type” issue in Oracle Cloud Infrastructure.

Introduction to OCI Monitoring

Oracle Corporation Cloud Infrastructure Monitoring is a native OCI service that helps organizations collect, analyze, and visualize infrastructure and application metrics.

OCI Monitoring enables teams to monitor:

• Compute instances
• Load balancers
• Autonomous Databases
• Kubernetes clusters
• Block volumes
• API Gateway
• Custom applications
• OIC integrations
• Logging Analytics integrations

The Monitoring service works with:

• Metrics
• Alarms
• Metric namespaces
• Dimensions
• Queries
• Notifications

In OCI 26A-aligned environments, OCI Observability services are heavily integrated with:

• Logging Analytics
• Application Performance Monitoring (APM)
• Stack Monitoring
• Operations Insights
• OCI Native Dashboards

What Does “Not a Supported Metric Type” Mean?

The error “Not a Supported Metric Type” usually indicates that OCI Monitoring cannot process the metric type specified in a query, alarm, API request, or monitoring configuration.

The issue occurs when:

• The metric namespace is invalid
• The metric does not exist
• The metric type is unsupported
• The metric aggregation is incompatible
• Custom metrics are incorrectly configured
• Unsupported dimensions are used
• Wrong OCI service metrics are referenced

The error may appear in:

• OCI Console
• OCI CLI
• REST APIs
• Terraform scripts
• OIC integrations
• SDK-based implementations

Common Locations Where the Error Appears

Metrics Explorer

OCI Console → Observability & Management → Monitoring → Metrics Explorer

Alarm Configuration

OCI Console → Observability & Management → Monitoring → Alarm Definitions

OCI CLI Commands

Example:

oci monitoring metric-data summarize-metrics-data

Terraform Deployments

Example:

resource "oci_monitoring_alarm" "cpu_alarm" {
}

REST API Integrations

OCI Monitoring APIs may return:

{
  "code": "InvalidParameter",
  "message": "Not a Supported Metric Type"
}

Understanding OCI Metric Architecture

Before troubleshooting the issue, it is important to understand how OCI Monitoring metrics work.

OCI Monitoring Components

OCI Metric Namespace Examples

Using an incorrect namespace is one of the biggest reasons for the unsupported metric type error.

Real-World Use Cases

Scenario 1 – Invalid CPU Metric Alarm

A cloud administrator attempts to create a CPU utilization alarm for a compute instance but uses an invalid metric name.

Incorrect metric:

CPU_UTIL

Correct metric:

CpuUtilization

OCI rejects the configuration because the metric type does not exist.

Scenario 2 – Unsupported OKE Cluster Metrics

A DevOps team tries monitoring Kubernetes pod metrics directly from OCI Monitoring without enabling Container Engine monitoring integrations.

OCI returns:

Not a Supported Metric Type

because the metric source is unavailable.

Scenario 3 – Custom Application Metrics Failure

A banking customer pushes application metrics using OCI SDKs but sends string values instead of numeric values.

Example:

"value": "High"

OCI Monitoring supports only numeric metric values.

Major Causes of the Error

1. Incorrect Metric Name

This is the most common issue.

Example:

Incorrect:

MemoryUsage

Correct:

MemoryUtilization

OCI metric names are case-sensitive.

2. Invalid Namespace

Using the wrong namespace causes OCI Monitoring to reject the query.

Example:

Incorrect:

oci_compute

Correct:

oci_computeagent

3. Unsupported Aggregation Type

Some metrics do not support all aggregation methods.

Example:

Unsupported:

SUM()

Supported:

AVG()
MAX()

4. Invalid Metric Dimensions

Incorrect dimensions can also trigger the issue.

Example:

Incorrect:

resourceId

Correct:

resourceDisplayName

5. Custom Metric Format Errors

OCI custom metrics require:

• Numeric values
• Proper namespace
• Correct dimensions
• Valid timestamps

Example of supported metric payload:

{
  "namespace": "custom_application",
  "name": "TransactionCount",
  "datapoints": [
    {
      "timestamp": "2026-05-15T10:00:00Z",
      "value": 150
    }
  ]
}

6. Service Does Not Publish Metrics

Some OCI services do not publish metrics by default.

Examples include:

• Newly provisioned resources
• Disabled monitoring agents
• Inactive integrations

OCI Monitoring Technical Flow

Step 1 – Resource Generates Metrics

Example:

• Compute instance generates CPU metrics
• Database generates storage metrics

Step 2 – OCI Monitoring Collects Metrics

OCI Monitoring service stores metrics internally.

Step 3 – Metrics Explorer Queries Metrics

The user executes queries using:

• OCI Console
• APIs
• CLI
• Terraform

Step 4 – Alarm Evaluates Metrics

OCI evaluates thresholds and triggers notifications.

If the metric format or type is unsupported, OCI rejects the request.

Prerequisites Before Configuring OCI Monitoring

Before creating alarms or metric queries:

Step-by-Step Troubleshooting Process

Step 1 – Verify the Namespace

Navigate to:

OCI Console → Observability & Management → Monitoring → Metrics Explorer

Select the namespace carefully.

Example:

oci_computeagent

Step 2 – Validate Available Metrics

Choose the resource and inspect available metrics.

Examples:

• CpuUtilization
• MemoryUtilization
• DiskBytesRead

Use only metrics visible in Metrics Explorer.

Step 3 – Validate Aggregation Type

Check whether the metric supports:

• AVG
• MAX
• COUNT
• RATE

Example valid query:

CpuUtilization[1m].mean()

Step 4 – Check Metric Dimensions

Example valid dimension:

resourceDisplayName = 'Prod-Server-01'

Avoid unsupported custom dimension names.

Step 5 – Validate IAM Policies

Example IAM policy:

Allow group MonitoringAdmins to read metrics in tenancy

Without permissions, OCI may fail metric validation.

Step 6 – Verify OCI Agent Status

For Compute metrics:

Navigate to:

Compute → Instance → Oracle Cloud Agent

Ensure:

• Monitoring plugin enabled
• Management plugin enabled

Step 7 – Test Using OCI CLI

Example:

oci monitoring metric-data summarize-metrics-data \
--namespace oci_computeagent \
--query-text "CpuUtilization[1m].mean()"

If successful, the metric is supported.

Step-by-Step Alarm Configuration Example

Step 1 – Navigate to Monitoring

OCI Console → Observability & Management → Alarm Definitions

Step 2 – Create Alarm

Enter:

Step 3 – Configure Notifications

Select an OCI Notifications topic.

Step 4 – Save Alarm

Click:

Create Alarm

Step 5 – Validate Alarm

Generate test CPU load.

Expected result:

• Alarm moves to FIRING state
• Notification delivered successfully

Testing Custom Metrics

Example Python SDK Payload

from oci.monitoring.models import PostMetricDataDetails

Example metric:

{
  "namespace": "finance_app",
  "name": "InvoiceProcessingTime",
  "value": 22
}

Expected Validation Checks

Common OCI Monitoring Errors

Common Implementation Challenges

1. Dynamic Resource Names

OCI environments with auto-scaling may create changing dimensions.

Solution:

Use dynamic queries.

2. Multi-Region Deployments

Metrics vary across regions.

Solution:

Validate metrics per region.

3. Custom Application Metrics

Teams often send invalid JSON payloads.

Solution:

Validate payload structure before API submission.

4. Terraform Misconfigurations

Hardcoded metrics may not exist in all environments.

Solution:

Use reusable Terraform variables.

5. OIC and OCI Integration Monitoring

OIC Gen 3 monitoring integrations sometimes reference unavailable metrics.

Solution:

Validate OIC observability metrics before deployment.

Best Practices for OCI Metrics Management

Use Metrics Explorer First

Always verify metrics in OCI Console before automation.

Follow OCI Naming Standards

Use official metric names from OCI documentation.

Enable OCI Agents

Without agents, many compute metrics will not appear.

Use Reusable Monitoring Templates

Standardize alarm definitions across projects.

Validate API Payloads

Always test custom metrics using Postman or OCI CLI first.

Monitor Namespace Consistency

Ensure:

• Dev
• Test
• Production

all use consistent namespaces.

Avoid Unsupported Aggregations

Not every metric supports:

• SUM
• RATE
• COUNT

Validate before implementation.

OCI Consultant Tips from Real Projects

Tip 1 – Export Metrics Using CLI

Use OCI CLI to confirm metric availability before Terraform deployment.

Tip 2 – Use Separate Namespaces for Custom Apps

Example:

finance_custom_metrics

This avoids namespace conflicts.

Tip 3 – Standardize Alarm Naming

Example:

PROD_CPU_HIGH
DEV_MEMORY_ALERT

This simplifies operations management.

Tip 4 – Enable Logging Analytics

OCI Logging Analytics provides better observability correlation.

Tip 5 – Use OCI Native Dashboards

Native dashboards reduce metric compatibility issues.

FAQ

1. What causes “Not a Supported Metric Type” in OCI?

The error usually occurs because of invalid metric names, unsupported namespaces, incorrect aggregations, or improperly configured custom metrics.

2. How can I find valid OCI metrics?

Navigate to:

OCI Console → Observability & Management → Metrics Explorer

OCI automatically displays supported metrics for selected resources.

3. Can custom metrics trigger this error?

Yes. Invalid payload formats, non-numeric values, or incorrect namespaces frequently cause the issue.

Summary

The “Not a Supported Metric Type” issue in Oracle Cloud Infrastructure is a common monitoring and observability error encountered during alarm configuration, metric queries, Terraform automation, and custom integrations.

In most enterprise OCI projects, the issue is caused by:

• Incorrect metric names
• Invalid namespaces
• Unsupported aggregations
• Missing monitoring agents
• Improper custom metric payloads

Understanding OCI Monitoring architecture, validating namespaces, testing metrics through Metrics Explorer, and following OCI observability best practices can help administrators quickly resolve the issue.

For large enterprise implementations, establishing standardized monitoring templates and governance processes significantly reduces metric-related deployment failures.

For additional technical details, refer to the official Oracle Cloud Infrastructure Documentation and OCI Monitoring guides from Oracle Docs Cloud Platform Index