chore: consolidate agent code for otlp (#1132)

## Overview

Consolidates the OTLP agent code by merging grpc_agent.rs into agent.rs,
eliminating ~280 lines of duplicated code. A single Agent struct now
owns a shared TracePipeline and starts HTTP, gRPC, or both servers based
on config.

## Changes
- Introduced TracePipeline struct holding shared state (config,
processor, trace channels, stats generator) with a
process_and_send_traces method used by both HTTP and gRPC handlers
- TraceService (gRPC) is implemented directly on TracePipeline, removing
the redundant OtlpGrpcService struct
- Agent now holds Option<u16> for http_port/grpc_port, spawning
whichever protocols are configured
- Collapsed should_enable_otlp_http + should_enable_otlp_grpc into a
single should_enable_otlp_agent
  - Deleted grpc_agent.rs
  - Simplified start_otlp_agent in main.rs: one Agent, one spawn

## Bug fixes
- parse_port scheme handling — HTTP agent's split(':').nth(1) broke on
endpoints with schemes like http://localhost:4318. Replaced with the
gRPC version that strips http:///https:// prefixes and uses rsplit(':')
for IPv6 support
- Empty trace check — HTTP handler checked size_of_val(&traces) == 0,
which always evaluates to false (returns the 24-byte stack size of the
Vec struct). Replaced with traces.iter().all(Vec::is_empty) in the
shared pipeline


## Tests

Merged and deduplicated parse_port tests (gained scheme-handling
coverage), consolidated enablement tests into should_enable_otlp_agent.
All 28 OTLP tests pass, zero clippy warnings.

Author: duncanista

bottlecap/src/bin/bottlecap/main.rs

@@ -52,10 +52,7 @@ use bottlecap::{
         },
         flusher::LogsFlusher,
     },
-    otlp::{
-        agent::Agent as OtlpAgent, grpc_agent::GrpcAgent as OtlpGrpcAgent, should_enable_otlp_grpc,
-        should_enable_otlp_http,
-    },
+    otlp::{agent::Agent as OtlpAgent, should_enable_otlp_agent},
     proxy::{interceptor, should_start_proxy},
     secrets::decrypt,
     tags::{
@@ -1357,49 +1354,27 @@ fn start_otlp_agent(
     trace_tx: Sender<SendDataBuilderInfo>,
     stats_concentrator: StatsConcentratorHandle,
 ) -> Option<CancellationToken> {
-    let http_enabled = should_enable_otlp_http(config);
-    let grpc_enabled = should_enable_otlp_grpc(config);
-
-    if !http_enabled && !grpc_enabled {
+    if !should_enable_otlp_agent(config) {
         return None;
     }
 
     let stats_generator = Arc::new(StatsGenerator::new(stats_concentrator));
     let cancel_token = CancellationToken::new();
 
-    if http_enabled {
-        let agent = OtlpAgent::new(
-            config.clone(),
-            tags_provider.clone(),
-            trace_processor.clone(),
-            trace_tx.clone(),
-            stats_generator.clone(),
-            cancel_token.clone(),
-        );
-
-        tokio::spawn(async move {
-            if let Err(e) = agent.start().await {
-                error!("Error starting OTLP HTTP agent: {e:?}");
-            }
-        });
-    }
-
-    if grpc_enabled {
-        let grpc_agent = OtlpGrpcAgent::new(
-            config.clone(),
-            tags_provider,
-            trace_processor,
-            trace_tx,
-            stats_generator,
-            cancel_token.clone(),
-        );
+    let agent = OtlpAgent::new(
+        config.clone(),
+        tags_provider,
+        trace_processor,
+        trace_tx,
+        stats_generator,
+        cancel_token.clone(),
+    );
 
-        tokio::spawn(async move {
-            if let Err(e) = grpc_agent.start().await {
-                error!("Error starting OTLP gRPC agent: {e:?}");
-            }
-        });
-    }
+    tokio::spawn(async move {
+        if let Err(e) = agent.start().await {
+            error!("Error starting OTLP agent: {e:?}");
+        }
+    });
 
     Some(cancel_token)
 }