Use SDKs to send metrics from applications

This document illustrates how you can send metrics directly from applications to the OTLP endpoint by using an SDK and the gRPC exporter, which is the recommended exporter for use with SDKs. The OTLP endpoint supports all of the OTLP protocols, including http/proto , http/json , and grpc . For more information, see Protocol support .

When you send application metrics directly to the OTLP endpoint, the OpenTelemetry Collector does not handle authentication and enrichment for you. When using SDKs to send metrics from applications, you need to do the following:

Configure credentials for the OTLP gRPC exporter to use Google Application Default Credentials , as described in Get authentication credentials .
Detect Google Cloud and Kubernetes resources from the application. How you do this depends on the application you're running.

Before you begin

To run the examples, you must enable the necessary APIs and acquire authentication credentials.

Enable APIs

Enable the Cloud Monitoring API and the Telemetry API in your Google Cloud project by running the following command:

gcloud services enable monitoring.googleapis.com telemetry.googleapis.com

Get authentication credentials

Configure credentials for the OTLP gRPC exporter to use Google Application Default Credentials by running the following command:

gcloud auth application-default login

Language-specific examples

This section provides a selection of language-specific samples that create and write a counter metric. Select a tab for information about running the sample and to view the code.

Go

For information about configuring and running this example, see the README file for the Go sample .

  // Copyright 2024 Google LLC 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License. 
 // You may obtain a copy of the License at 
 // 
 //     http://www.apache.org/licenses/LICENSE-2.0 
 // 
 // Unless required by applicable law or agreed to in writing, software 
 // distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 // See the License for the specific language governing permissions and 
 // limitations under the License. 
 package 
  
 main 
 import 
  
 ( 
  
 "context" 
  
 "errors" 
  
 "log" 
  
 "go.opentelemetry.io/contrib/detectors/gcp" 
  
 "go.opentelemetry.io/otel/attribute" 
  
 "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc" 
  
 "go.opentelemetry.io/otel/metric" 
  
 sdkmetric 
  
 "go.opentelemetry.io/otel/sdk/metric" 
  
 "go.opentelemetry.io/otel/sdk/resource" 
  
 semconv 
  
 "go.opentelemetry.io/otel/semconv/v1.37.0" 
  
 "google.golang.org/grpc" 
  
 "google.golang.org/grpc/credentials/oauth" 
 ) 
 func 
  
 main 
 () 
  
 { 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 creds 
 , 
  
 err 
  
 := 
  
 oauth 
 . 
 NewApplicationDefault 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 panic 
 ( 
 err 
 ) 
  
 } 
  
 res 
 , 
  
 err 
  
 := 
  
 resource 
 . 
 New 
 ( 
  
 ctx 
 , 
  
 // Use the GCP resource detector to detect information about the GCP platform 
  
 resource 
 . 
 WithDetectors 
 ( 
 gcp 
 . 
 NewDetector 
 ()), 
  
 // Keep the default detectors 
  
 resource 
 . 
 WithTelemetrySDK 
 (), 
  
 // Add attributes from environment variables 
  
 resource 
 . 
 WithFromEnv 
 (), 
  
 // Add your own custom attributes to identify your application 
  
 resource 
 . 
 WithAttributes 
 ( 
  
 semconv 
 . 
 ServiceNameKey 
 . 
 String 
 ( 
 "example-application" 
 ), 
  
 ), 
  
 ) 
  
 if 
  
 errors 
 . 
 Is 
 ( 
 err 
 , 
  
 resource 
 . 
 ErrPartialResource 
 ) 
  
 || 
  
 errors 
 . 
 Is 
 ( 
 err 
 , 
  
 resource 
 . 
 ErrSchemaURLConflict 
 ) 
  
 { 
  
 log 
 . 
 Println 
 ( 
 err 
 ) 
  
 } 
  
 else 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 panic 
 ( 
 err 
 ) 
  
 } 
  
 // Set endpoint with OTEL_EXPORTER_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_METRICS_ENDPOINT 
  
 metricExporter 
 , 
  
 err 
  
 := 
  
 otlpmetricgrpc 
 . 
 New 
 ( 
 ctx 
 , 
  
 otlpmetricgrpc 
 . 
 WithDialOption 
 ( 
 grpc 
 . 
 WithPerRPCCredentials 
 ( 
 creds 
 ))) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 panic 
 ( 
 err 
 ) 
  
 } 
  
 meterProvider 
  
 := 
  
 sdkmetric 
 . 
 NewMeterProvider 
 ( 
  
 sdkmetric 
 . 
 WithResource 
 ( 
 res 
 ), 
  
 sdkmetric 
 . 
 WithReader 
 ( 
 sdkmetric 
 . 
 NewPeriodicReader 
 ( 
 metricExporter 
 )), 
  
 ) 
  
 defer 
  
 func 
 () 
  
 { 
  
 if 
  
 err 
  
 = 
  
 meterProvider 
 . 
 Shutdown 
 ( 
 ctx 
 ); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 log 
 . 
 Println 
 ( 
 err 
 ) 
  
 } 
  
 }() 
  
 meter 
  
 := 
  
 meterProvider 
 . 
 Meter 
 ( 
 "github.com/GoogleCloudPlatform/opentelemetry-operations-go/example/metric/otlpgrpc" 
 ) 
  
 // Register counter value 
  
 counter 
 , 
  
 err 
  
 := 
  
 meter 
 . 
 Int64Counter 
 ( 
 "counter-a" 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 log 
 . 
 Fatalf 
 ( 
 "Failed to create counter: %v" 
 , 
  
 err 
 ) 
  
 } 
  
 clabels 
  
 := 
  
 [] 
 attribute 
 . 
 KeyValue 
 { 
 attribute 
 . 
 Key 
 ( 
 "key" 
 ). 
 String 
 ( 
 "value" 
 )} 
  
 counter 
 . 
 Add 
 ( 
 ctx 
 , 
  
 100 
 , 
  
 metric 
 . 
 WithAttributes 
 ( 
 clabels 
 ... 
 )) 
 }

Java

For information about configuring and running this example, see the README file for the Java sample .

  /* 
 * Copyright 2025 Google LLC 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 
 package 
  
 com.google.cloud.opentelemetry.example.otlpmetric 
 ; 
 import 
  
 com.google.auth.oauth2. GoogleCredentials 
 
 ; 
 import 
  
 io.opentelemetry.api.metrics.LongCounter 
 ; 
 import 
  
 io.opentelemetry.exporter.otlp.http.metrics.OtlpHttpMetricExporter 
 ; 
 import 
  
 io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter 
 ; 
 import 
  
 io.opentelemetry.sdk.OpenTelemetrySdk 
 ; 
 import 
  
 io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk 
 ; 
 import 
  
 io.opentelemetry.sdk.common.CompletableResultCode 
 ; 
 import 
  
 io.opentelemetry.sdk.metrics.export.MetricExporter 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.util.HashMap 
 ; 
 import 
  
 java.util.Map 
 ; 
 import 
  
 java.util.Random 
 ; 
 import 
  
 java.util.concurrent.TimeUnit 
 ; 
 public 
  
 class 
 OTLPMetricExample 
  
 { 
  
 private 
  
 static 
  
 final 
  
 String 
  
 INSTRUMENTATION_SCOPE_NAME 
  
 = 
  
 OTLPMetricExample 
 . 
 class 
 . 
 getName 
 (); 
  
 private 
  
 static 
  
 final 
  
 Random 
  
 RANDOM 
  
 = 
  
 new 
  
 Random 
 (); 
  
 private 
  
 static 
  
 OpenTelemetrySdk 
  
 openTelemetrySdk 
 ; 
  
 private 
  
 static 
  
 OpenTelemetrySdk 
  
 setupMetricExporter 
 () 
  
 throws 
  
 IOException 
  
 { 
  
  GoogleCredentials 
 
  
 credentials 
  
 = 
  
  GoogleCredentials 
 
 . 
  getApplicationDefault 
 
 (); 
  
 // Update the SDK configured using environment variables and system properties 
  
 // TODO: Replace this with the use of gcp-auth-extension 
  
 AutoConfiguredOpenTelemetrySdk 
  
 autoConfOTelSdk 
  
 = 
  
 AutoConfiguredOpenTelemetrySdk 
 . 
 builder 
 () 
  
 . 
 addMetricExporterCustomizer 
 ( 
  
 ( 
 exporter 
 , 
  
 configProperties 
 ) 
  
 - 
>  
 addAuthorizationHeaders 
 ( 
 exporter 
 , 
  
 credentials 
 )) 
  
 . 
 build 
 (); 
  
 return 
  
 autoConfOTelSdk 
 . 
 getOpenTelemetrySdk 
 (); 
  
 } 
  
 // Modifies the metric exporter initially auto-configured using environment variables 
  
 // This will invoke the header supplier function to compute the headers, which takes care of the 
  
 // refresh. 
  
 private 
  
 static 
  
 MetricExporter 
  
 addAuthorizationHeaders 
 ( 
  
 MetricExporter 
  
 exporter 
 , 
  
  GoogleCredentials 
 
  
 credentials 
 ) 
  
 { 
  
 if 
  
 ( 
 exporter 
  
 instanceof 
  
 OtlpHttpMetricExporter 
 ) 
  
 { 
  
 return 
  
 (( 
 OtlpHttpMetricExporter 
 ) 
  
 exporter 
 ) 
  
 . 
 toBuilder 
 (). 
  setHeaders 
 
 (() 
  
 - 
>  
 getRequiredHeaderMap 
 ( 
 credentials 
 )). 
 build 
 (); 
  
 } 
  
 else 
  
 if 
  
 ( 
 exporter 
  
 instanceof 
  
 OtlpGrpcMetricExporter 
 ) 
  
 { 
  
 return 
  
 (( 
 OtlpGrpcMetricExporter 
 ) 
  
 exporter 
 ) 
  
 . 
 toBuilder 
 (). 
  setHeaders 
 
 (() 
  
 - 
>  
 getRequiredHeaderMap 
 ( 
 credentials 
 )). 
 build 
 (); 
  
 } 
  
 return 
  
 exporter 
 ; 
  
 } 
  
 private 
  
 static 
  
 Map<String 
 , 
  
 String 
>  
 getRequiredHeaderMap 
 ( 
  GoogleCredentials 
 
  
 credentials 
 ) 
  
 { 
  
 Map<String 
 , 
  
 String 
>  
 gcpHeaders 
  
 = 
  
 new 
  
 HashMap 
<> (); 
  
 try 
  
 { 
  
 credentials 
 . 
  refreshIfExpired 
 
 (); 
  
 } 
  
 catch 
  
 ( 
 IOException 
  
 e 
 ) 
  
 { 
  
 throw 
  
 new 
  
 RuntimeException 
 ( 
 e 
 ); 
  
 } 
  
 gcpHeaders 
 . 
 put 
 ( 
 "Authorization" 
 , 
  
 "Bearer " 
  
 + 
  
 credentials 
 . 
 getAccessToken 
 (). 
 getTokenValue 
 ()); 
  
 String 
  
 configuredQuotaProjectId 
  
 = 
  
 credentials 
 . 
  getQuotaProjectId 
 
 (); 
  
 if 
  
 ( 
 configuredQuotaProjectId 
  
 != 
  
 null 
 && 
 ! 
 configuredQuotaProjectId 
 . 
 isEmpty 
 ()) 
  
 { 
  
 gcpHeaders 
 . 
 put 
 ( 
 "x-goog-user-project" 
 , 
  
 configuredQuotaProjectId 
 ); 
  
 } 
  
 return 
  
 gcpHeaders 
 ; 
  
 } 
  
 private 
  
 static 
  
 void 
  
 myUseCase 
 () 
  
 { 
  
 LongCounter 
  
 counter 
  
 = 
  
 openTelemetrySdk 
  
 . 
 getMeter 
 ( 
 INSTRUMENTATION_SCOPE_NAME 
 ) 
  
 . 
 counterBuilder 
 ( 
 "example_counter" 
 ) 
  
 . 
  setDescription 
 
 ( 
 "Processed jobs" 
 ) 
  
 . 
 setUnit 
 ( 
 "1" 
 ) 
  
 . 
 build 
 (); 
  
 doWork 
 ( 
 counter 
 ); 
  
 } 
  
 private 
  
 static 
  
 void 
  
 doWork 
 ( 
 LongCounter 
  
 counter 
 ) 
  
 { 
  
 try 
  
 { 
  
 for 
  
 ( 
 int 
  
 i 
  
 = 
  
 0 
 ; 
  
 i 
 < 
 10 
 ; 
  
 i 
 ++ 
 ) 
  
 { 
  
 counter 
 . 
 add 
 ( 
 RANDOM 
 . 
 nextInt 
 ( 
 100 
 )); 
  
 Thread 
 . 
 sleep 
 ( 
 RANDOM 
 . 
 nextInt 
 ( 
 1000 
 )); 
  
 } 
  
 } 
  
 catch 
  
 ( 
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 throw 
  
 new 
  
 RuntimeException 
 ( 
 e 
 ); 
  
 } 
  
 } 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 // Configure the OpenTelemetry pipeline with CloudMetric exporter 
  
 openTelemetrySdk 
  
 = 
  
 setupMetricExporter 
 (); 
  
 // Application-specific logic 
  
 myUseCase 
 (); 
  
 // Flush all buffered metrics 
  
 CompletableResultCode 
  
 completableResultCode 
  
 = 
  
 openTelemetrySdk 
 . 
 getSdkMeterProvider 
 (). 
 shutdown 
 (); 
  
 // wait till export finishes 
  
 completableResultCode 
 . 
 join 
 ( 
 10000 
 , 
  
 TimeUnit 
 . 
 MILLISECONDS 
 ); 
  
 } 
 }

NodeJS

For information about configuring and running this example, see the README file for the NodeJS sample .

  // Copyright 2025 Google LLC 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License. 
 // You may obtain a copy of the License at 
 // 
 //      https://www.apache.org/licenses/LICENSE-2.0 
 // 
 // Unless required by applicable law or agreed to in writing, software 
 // distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 // See the License for the specific language governing permissions and 
 // limitations under the License. 
 import 
  
 * 
  
 as 
  
 opentelemetry 
  
 from 
  
 '@opentelemetry/sdk-node' 
 ; 
 import 
  
 { 
 AuthClient 
 , 
  
 GoogleAuth 
 } 
  
 from 
  
 'google-auth-library' 
 ; 
 import 
  
 { 
 credentials 
 } 
  
 from 
  
 '@grpc/grpc-js' 
 ; 
 import 
  
 { 
 getResourceDetectors 
  
 as 
  
 getResourceDetectorsFromEnv 
 } 
  
 from 
  
 '@opentelemetry/auto-instrumentations-node' 
 ; 
 import 
  
 { 
 metrics 
 , 
  
 diag 
 , 
  
 DiagConsoleLogger 
 } 
  
 from 
  
 '@opentelemetry/api' 
 ; 
 import 
  
 { 
 OTLPMetricExporter 
 } 
  
 from 
  
 '@opentelemetry/exporter-metrics-otlp-grpc' 
 ; 
 import 
  
 { 
 PeriodicExportingMetricReader 
 } 
  
 from 
  
 '@opentelemetry/sdk-metrics' 
 ; 
 async 
  
 function 
  
 getAuthenticatedClient 
 () 
 : 
  
 Promise<AuthClient> 
  
 { 
  
 const 
  
 auth 
 : 
  
 GoogleAuth 
  
 = 
  
 new 
  
 GoogleAuth 
 ({ 
  
 scopes 
 : 
  
 'https://www.googleapis.com/auth/cloud-platform' 
 , 
  
 }); 
  
 return 
  
 await 
  
 auth 
 . 
 getClient 
 (); 
 } 
 diag 
 . 
 setLogger 
 ( 
  
 new 
  
 DiagConsoleLogger 
 (), 
  
 opentelemetry 
 . 
 core 
 . 
 diagLogLevelFromString 
 ( 
  
 opentelemetry 
 . 
 core 
 . 
 getStringFromEnv 
 ( 
 'OTEL_LOG_LEVEL' 
 ), 
  
 ), 
 ); 
 // App that exports metrics via gRPC with protobuf 
 async 
  
 function 
  
 main 
 () 
  
 { 
  
 const 
  
 authenticatedClient 
 : 
  
 AuthClient 
  
 = 
  
 await 
  
 getAuthenticatedClient 
 (); 
  
 const 
  
 sdk 
  
 = 
  
 new 
  
 opentelemetry 
 . 
 NodeSDK 
 ({ 
  
 metricReader 
 : 
  
 new 
  
 PeriodicExportingMetricReader 
 ({ 
  
 // Export metrics every 10 seconds. 5 seconds is the smallest sample period allowed by 
  
 // Cloud Monitoring. 
  
 exportIntervalMillis 
 : 
  
 10 
 _000 
 , 
  
 exporter 
 : 
  
 new 
  
 OTLPMetricExporter 
 ({ 
  
 credentials 
 : 
  
 credentials 
 . 
 combineChannelCredentials 
 ( 
  
 credentials 
 . 
 createSsl 
 (), 
  
 credentials 
 . 
 createFromGoogleCredential 
 ( 
 authenticatedClient 
 ), 
  
 ), 
  
 }), 
  
 }), 
  
 resourceDetectors 
 : 
  
 getResourceDetectorsFromEnv 
 (), 
  
 }); 
  
 sdk 
 . 
 start 
 (); 
  
 // Create a meter 
  
 const 
  
 meter 
  
 = 
  
 metrics 
 . 
 getMeter 
 ( 
 'metrics-sample' 
 ); 
  
 // Create a counter instrument 
  
 const 
  
 counter 
  
 = 
  
 meter 
 . 
 createCounter 
 ( 
 'metric_name' 
 ); 
  
 // Record a measurement 
  
 counter 
 . 
 add 
 ( 
 10 
 , 
  
 { 
 key 
 : 
  
 'value' 
 }); 
  
 // Wait for the metric to be exported 
  
 await 
  
 new 
  
 Promise 
 ( 
 resolve 
  
 = 
>  
 { 
  
 setTimeout 
 ( 
 resolve 
 , 
  
 11 
 _000 
 ); 
  
 }); 
  
 // Gracefully shut down the SDK to flush telemetry when the program exits 
  
 process 
 . 
 on 
 ( 
 'SIGTERM' 
 , 
  
 () 
  
 = 
>  
 { 
  
 sdk 
  
 . 
 shutdown 
 () 
  
 . 
 then 
 (() 
  
 = 
>  
 diag 
 . 
 debug 
 ( 
 'OpenTelemetry SDK terminated' 
 )) 
  
 . 
 catch 
 ( 
 error 
  
 = 
>  
 diag 
 . 
 error 
 ( 
 'Error terminating OpenTelemetry SDK' 
 , 
  
 error 
 )); 
  
 }); 
 } 
 main 
 (). 
 catch 
 ( 
 console 
 . 
 error 
 );

Python

For information about running this example, see the README file for the README file for the Python sample .

  #!/usr/bin/env python3 
 # Copyright 2025 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     http://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 import 
  
 time 
 import 
  
 google.auth 
 import 
  
 google.auth.transport.grpc 
 import 
  
 google.auth.transport.requests 
 import 
  
 grpc 
 from 
  
 google.auth.transport.grpc 
  
 import 
 AuthMetadataPlugin 
 from 
  
 opentelemetry.exporter.otlp.proto.grpc.metric_exporter 
  
 import 
 ( 
 OTLPMetricExporter 
 , 
 ) 
 from 
  
 opentelemetry.resourcedetector.gcp_resource_detector 
  
 import 
 GoogleCloudResourceDetector 
 from 
  
 opentelemetry.sdk.resources 
  
 import 
 get_aggregated_resources 
 from 
  
 opentelemetry.sdk.metrics 
  
 import 
 MeterProvider 
 from 
  
 opentelemetry.sdk.metrics.export 
  
 import 
 PeriodicExportingMetricReader 
 """ 
 This is a sample script that exports OTLP metrics encoded as protobufs via gRPC. 
 """ 
 credentials 
 , 
 project_id 
 = 
 google 
 . 
 auth 
 . 
 default 
 () 
 request 
 = 
 google 
 . 
 auth 
 . 
 transport 
 . 
 requests 
 . 
 Request 
 () 
 resource 
 = 
 get_aggregated_resources 
 ( 
 [ 
 GoogleCloudResourceDetector 
 ( 
 raise_on_error 
 = 
 True 
 )] 
 ) 
 auth_metadata_plugin 
 = 
 AuthMetadataPlugin 
 ( 
 credentials 
 = 
 credentials 
 , 
 request 
 = 
 request 
 ) 
 channel_creds 
 = 
 grpc 
 . 
 composite_channel_credentials 
 ( 
 grpc 
 . 
 ssl_channel_credentials 
 (), 
 grpc 
 . 
 metadata_call_credentials 
 ( 
 auth_metadata_plugin 
 ), 
 ) 
 exporter 
 = 
 OTLPMetricExporter 
 ( 
 credentials 
 = 
 channel_creds 
 ) 
 reader 
 = 
 PeriodicExportingMetricReader 
 ( 
 exporter 
 ) 
 provider 
 = 
 MeterProvider 
 ( 
 metric_readers 
 = 
 [ 
 reader 
 ], 
 resource 
 = 
 resource 
 ) 
 meter 
 = 
 provider 
 . 
 get_meter 
 ( 
 "gcp.otlp.sample" 
 ) 
 counter 
 = 
 meter 
 . 
 create_counter 
 ( 
 "sample.otlp.counter" 
 ) 
 def 
  
 do_work 
 (): 
 counter 
 . 
 add 
 ( 
 1 
 ) 
 # do some work that the 'counter' will track 
 print 
 ( 
 "doing some work..." 
 ) 
 def 
  
 do_work_repeatedly 
 (): 
 try 
 : 
 while 
 True 
 : 
 do_work 
 () 
 time 
 . 
 sleep 
 ( 
 1 
 ) 
 except 
 KeyboardInterrupt 
 : 
 print 
 ( 
 " 
 \n 
 Keyboard Interrupt: Stopping work." 
 ) 
 do_work_repeatedly 
 ()

Use the downward API for applications running as pods

If you are running the application as a pod in Kubernetes and are not sending through the OpenTelemetry Collector, make sure to use the downward API to set Kubernetes resource attributes:

  env 
 : 
 - 
  
 name 
 : 
  
 POD_NAME 
  
 valueFrom 
 : 
  
 fieldRef 
 : 
  
 fieldPath 
 : 
  
 metadata.name 
 - 
  
 name 
 : 
  
 NAMESPACE_NAME 
  
 valueFrom 
 : 
  
 fieldRef 
 : 
  
 fieldPath 
 : 
  
 metadata.namespace 
 - 
  
 name 
 : 
  
 CONTAINER_NAME 
  
 value 
 : 
  
 my-container-name 
 - 
  
 name 
 : 
  
 OTEL_RESOURCE_ATTRIBUTES 
  
 value 
 : 
  
 k8s.pod.name=$(POD_NAME),k8s.namespace.name=$(NAMESPACE_NAME),k8s.container.name=$(CONTAINER_NAME)

What's next

For information about using an OpenTelemetry Collector and the Telemetry API with OpenTelemetry zero-code instrumentation, see Use OpenTelemetry zero-code instrumentation for Java .
For information about migrating to the otlphttp exporter from another exporter, see Migrate to the OTLP exporter .
To learn more about the Telemetry API, see Telemetry (OTLP) API overview .