mirror of
https://github.com/hanzoai/otel-collector.git
synced 2026-11-03 02:20:04 +00:00
68ce98920a
* feat(zap): native ZAP-transport OTLP receiver + exporter
Adds ZAP-native telemetry ingestion/forwarding over github.com/zap-proto/http
(the Hanzo ZAP wire — capnp frames, X-Wing PQ-KEM handshake), NOT OTLP-HTTP
(:4318) or OTLP-gRPC (:4317). The payload stays standard OTLP protobuf so full
OTel fidelity + pipeline interop are preserved; only the transport is ZAP.
- receiver/zapreceiver: runs a zaphttp.Server on :4319, terminates OTLP over
the ZAP wire on /v1/{traces,logs,metrics}, decodes to pdata, pushes to the
pipeline (-> ClickHouse exporters -> hanzoai/datastore). ObsReport transport
label is "zap". One listener serves all three signals.
- exporter/zapexporter: pdata -> OTLP proto -> zaphttp POST to a peer collector's
ZAP receiver (used by the filelog log-agent to ship node logs over ZAP).
- Registered in components.go alongside otlpreceiver (OTLP retained as an
interop endpoint for third-party SDKs).
Tests: TestZapReceiverAllSignals (traces+logs+metrics e2e over the real ZAP
wire) and TestExportTracesOverZAP both green; full ./components build clean.
* build(zap): self-building multi-stage Dockerfile for in-cluster Kaniko/BuildKit
The default Dockerfile COPYs a CI-prebuilt binary; this compiles in-image so an
in-cluster BuildKit/Kaniko job (platform.hanzo.ai) can produce the ZAP-enabled
image without the (currently broken) GitHub reusable workflow.
---------
Co-authored-by: hanzo-dev <[email protected]>
86 lines
2.2 KiB
Go
86 lines
2.2 KiB
Go
package zapreceiver
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"go.opentelemetry.io/collector/component"
|
|
"go.opentelemetry.io/collector/consumer"
|
|
"go.opentelemetry.io/collector/receiver"
|
|
)
|
|
|
|
// typeStr is the config `receivers:` key for this component.
|
|
var typeStr = component.MustNewType("zap")
|
|
|
|
// defaultEndpoint is the ZAP telemetry port. It is deliberately NOT 4317
|
|
// (OTLP-gRPC) or 4318 (OTLP-HTTP): those remain the interop OTLP endpoints,
|
|
// while :4319 carries the ZAP-native wire that Hanzo services use.
|
|
const defaultEndpoint = "0.0.0.0:4319"
|
|
|
|
const stability = component.StabilityLevelBeta
|
|
|
|
// NewFactory returns a receiver.Factory for the ZAP-native OTLP receiver. A
|
|
// single listener serves all three signals; the signal factories share one
|
|
// receiver instance keyed by config, so `traces`, `logs`, and `metrics`
|
|
// pipelines that reference the same receiver bind exactly one port.
|
|
func NewFactory() receiver.Factory {
|
|
return receiver.NewFactory(
|
|
typeStr,
|
|
createDefaultConfig,
|
|
receiver.WithTraces(createTraces, stability),
|
|
receiver.WithLogs(createLogs, stability),
|
|
receiver.WithMetrics(createMetrics, stability),
|
|
)
|
|
}
|
|
|
|
func createDefaultConfig() component.Config {
|
|
return &Config{Endpoint: defaultEndpoint}
|
|
}
|
|
|
|
var (
|
|
recvMu sync.Mutex
|
|
recvs = map[*Config]*zapReceiver{}
|
|
)
|
|
|
|
func ensure(set receiver.Settings, cfg *Config) (*zapReceiver, error) {
|
|
recvMu.Lock()
|
|
defer recvMu.Unlock()
|
|
r := recvs[cfg]
|
|
if r == nil {
|
|
var err error
|
|
r, err = newReceiver(set, cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
recvs[cfg] = r
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func createTraces(_ context.Context, set receiver.Settings, cfg component.Config, next consumer.Traces) (receiver.Traces, error) {
|
|
r, err := ensure(set, cfg.(*Config))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
r.traces = next
|
|
return r, nil
|
|
}
|
|
|
|
func createLogs(_ context.Context, set receiver.Settings, cfg component.Config, next consumer.Logs) (receiver.Logs, error) {
|
|
r, err := ensure(set, cfg.(*Config))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
r.logs = next
|
|
return r, nil
|
|
}
|
|
|
|
func createMetrics(_ context.Context, set receiver.Settings, cfg component.Config, next consumer.Metrics) (receiver.Metrics, error) {
|
|
r, err := ensure(set, cfg.(*Config))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
r.metrics = next
|
|
return r, nil
|
|
}
|