├── .chloggen ├── TEMPLATE.yaml ├── config.yaml └── use-sync │ └── atomic.yaml ├── .codecov.yml ├── .github ├── CODEOWNERS ├── ISSUE_TEMPLATE │ ├── bug_report.md │ ├── feature_request.md │ └── release.md ├── dependabot.yml ├── pull_request_template.md └── workflows │ ├── api-compatibility.yml │ ├── build-and-test-windows.yaml │ ├── build-and-test.yml │ ├── builder-integration-test.yaml │ ├── builder-release.yaml │ ├── changelog.yml │ ├── check-links.yaml │ ├── check_links_config.json │ ├── codeql-analysis.yml │ ├── contrib-tests.yml │ ├── create-dependabot-pr.yml │ ├── milestone-add-to-pr.yml │ ├── perf.yml │ ├── prepare-release.yml │ ├── scripts │ ├── dependabot-pr.sh │ ├── release-check-blockers.sh │ ├── release-check-build-status.sh │ ├── release-create-tracking-issue.sh │ └── release-prepare-release.sh │ ├── shellcheck.yml │ ├── stale-pr.yaml │ └── tidy-dependencies.yml ├── .gitignore ├── .gitmodules ├── .golangci.yml ├── CHANGELOG-API.md ├── CHANGELOG.md ├── CODEOWNERS ├── CONTRIBUTING.md ├── LICENSE ├── Makefile ├── Makefile.Common ├── README.md ├── VERSIONING.md ├── client ├── client.go ├── client_test.go └── doc_test.go ├── cmd ├── builder │ ├── .goreleaser.yml │ ├── Makefile │ ├── README.md │ ├── RELEASE.md │ ├── go.mod │ ├── go.sum │ ├── header.txt │ ├── internal │ │ ├── builder │ │ │ ├── config.go │ │ │ ├── config_test.go │ │ │ ├── main.go │ │ │ ├── main_test.go │ │ │ ├── templates.go │ │ │ └── templates │ │ │ │ ├── components.go.tmpl │ │ │ │ ├── components_test.go.tmpl │ │ │ │ ├── go.mod.tmpl │ │ │ │ ├── main.go.tmpl │ │ │ │ ├── main_others.go.tmpl │ │ │ │ └── main_windows.go.tmpl │ │ ├── command.go │ │ ├── command_test.go │ │ ├── config │ │ │ ├── default.go │ │ │ └── default.yaml │ │ └── version.go │ ├── main.go │ └── test │ │ ├── README.md │ │ ├── core.builder.yaml │ │ ├── core.otel.yaml │ │ ├── default.otel.yaml │ │ └── test.sh └── otelcorecol │ ├── Makefile │ ├── builder-config.yaml │ ├── components.go │ ├── components_test.go │ ├── go.mod │ ├── go.sum │ ├── main.go │ ├── main_others.go │ └── main_windows.go ├── component ├── Makefile ├── build_info.go ├── component.go ├── component_test.go ├── componenttest │ ├── configtest.go │ ├── configtest_test.go │ ├── doc.go │ ├── nop_host.go │ ├── nop_host_test.go │ ├── nop_telemetry.go │ └── nop_telemetry_test.go ├── config.go ├── config_test.go ├── doc.go ├── go.mod ├── go.sum ├── host.go ├── identifiable.go ├── identifiable_test.go └── telemetry.go ├── config ├── configauth │ ├── Makefile │ ├── README.md │ ├── configauth.go │ ├── configauth_test.go │ ├── go.mod │ └── go.sum ├── configcompression │ ├── Makefile │ ├── compressionType.go │ ├── compressionType_test.go │ ├── go.mod │ └── go.sum ├── configgrpc │ ├── Makefile │ ├── README.md │ ├── configgrpc.go │ ├── configgrpc_benchmark_test.go │ ├── configgrpc_test.go │ ├── doc.go │ ├── go.mod │ ├── go.sum │ ├── gzip.go │ ├── testdata │ │ ├── ca.crt │ │ ├── client.crt │ │ ├── client.key │ │ ├── server.crt │ │ └── server.key │ ├── wrappedstream.go │ └── wrappedstream_test.go ├── confighttp │ ├── Makefile │ ├── README.md │ ├── clientinfohandler.go │ ├── clientinfohandler_test.go │ ├── compression.go │ ├── compression_test.go │ ├── compressor.go │ ├── confighttp.go │ ├── confighttp_test.go │ ├── doc.go │ ├── go.mod │ ├── go.sum │ └── testdata │ │ ├── ca.crt │ │ ├── client.crt │ │ ├── client.key │ │ ├── server.crt │ │ └── server.key ├── confignet │ ├── Makefile │ ├── README.md │ ├── confignet.go │ ├── confignet_test.go │ ├── doc.go │ ├── go.mod │ └── go.sum ├── configopaque │ ├── Makefile │ ├── doc.go │ ├── doc_test.go │ ├── go.mod │ ├── go.sum │ ├── opaque.go │ └── opaque_test.go ├── configtelemetry │ ├── Makefile │ ├── configtelemetry.go │ ├── configtelemetry_test.go │ ├── doc.go │ ├── go.mod │ └── go.sum ├── configtls │ ├── Makefile │ ├── README.md │ ├── clientcasfilereloader.go │ ├── clientcasfilereloader_test.go │ ├── configtls.go │ ├── configtls_test.go │ ├── doc.go │ ├── go.mod │ ├── go.sum │ └── testdata │ │ ├── ca-1.crt │ │ ├── ca-2.crt │ │ ├── client-1.crt │ │ ├── client-1.key │ │ ├── client-2.crt │ │ ├── client-2.key │ │ ├── server-1.crt │ │ ├── server-1.key │ │ ├── server-2.crt │ │ ├── server-2.key │ │ └── testCA-bad.txt └── internal │ ├── Makefile │ ├── go.mod │ ├── go.sum │ ├── warning.go │ └── warning_test.go ├── confmap ├── Makefile ├── README.md ├── confmap.go ├── confmap_test.go ├── confmaptest │ ├── configtest.go │ ├── configtest_test.go │ ├── doc.go │ └── testdata │ │ ├── invalid.yaml │ │ └── simple.yaml ├── converter.go ├── converter │ └── expandconverter │ │ ├── expand.go │ │ ├── expand_test.go │ │ └── testdata │ │ ├── default-config.yaml │ │ ├── expand-escaped-env.yaml │ │ ├── expand-with-all-env.yaml │ │ ├── expand-with-no-env.yaml │ │ └── expand-with-partial-env.yaml ├── expand.go ├── expand_test.go ├── go.mod ├── go.sum ├── internal │ └── mapstructure │ │ ├── encoder.go │ │ └── encoder_test.go ├── provider.go ├── provider │ ├── envprovider │ │ ├── provider.go │ │ └── provider_test.go │ ├── fileprovider │ │ ├── provider.go │ │ ├── provider_test.go │ │ └── testdata │ │ │ ├── default-config.yaml │ │ │ └── invalid-yaml.yaml │ ├── httpprovider │ │ ├── README.md │ │ ├── provider.go │ │ └── provider_test.go │ ├── httpsprovider │ │ ├── README.md │ │ ├── provider.go │ │ └── provider_test.go │ ├── internal │ │ ├── configurablehttpprovider │ │ │ ├── provider.go │ │ │ ├── provider_test.go │ │ │ └── testdata │ │ │ │ └── otel-config.yaml │ │ ├── provider.go │ │ └── provider_test.go │ └── yamlprovider │ │ ├── provider.go │ │ └── provider_test.go ├── provider_test.go ├── resolver.go ├── resolver_test.go └── testdata │ ├── basic_types.yaml │ ├── config.yaml │ ├── embedded_keys.yaml │ ├── expand-with-all-env.yaml │ ├── expand-with-no-env.yaml │ └── expand-with-partial-env.yaml ├── connector ├── Makefile ├── README.md ├── connector.go ├── connector_test.go ├── connectortest │ ├── connector.go │ ├── connector_test.go │ ├── router.go │ └── router_test.go ├── forwardconnector │ ├── Makefile │ ├── README.md │ ├── doc.go │ ├── forward.go │ ├── forward_test.go │ ├── go.mod │ └── go.sum ├── go.mod └── go.sum ├── consumer ├── Makefile ├── consumer.go ├── consumererror │ ├── doc.go │ ├── permanent.go │ ├── permanent_test.go │ ├── signalerrors.go │ └── signalerrors_test.go ├── consumertest │ ├── consumer.go │ ├── doc.go │ ├── err.go │ ├── err_test.go │ ├── nop.go │ ├── nop_test.go │ ├── sink.go │ └── sink_test.go ├── doc.go ├── go.mod ├── go.sum ├── logs.go ├── logs_test.go ├── metrics.go ├── metrics_test.go ├── traces.go └── traces_test.go ├── docs ├── design.md ├── ga-roadmap.md ├── images │ ├── design-collector-agent.png │ ├── design-collector-service.png │ ├── design-exporters.png │ ├── design-pipelines.png │ ├── design-processors.png │ ├── design-receivers.png │ ├── design-service-lifecycle.png │ ├── opentelemetry-service-deployment-models.png │ └── zpages-example.png ├── monitoring.md ├── observability.md ├── performance.md ├── processing.md ├── release.md ├── roadmap.md ├── scraping-receivers.md ├── security-best-practices.md ├── service-extensions.md ├── standard-warnings.md ├── troubleshooting.md └── vision.md ├── examples ├── README.md ├── k8s │ └── otel-config.yaml └── local │ └── otel-config.yaml ├── exporter ├── Makefile ├── README.md ├── exporter.go ├── exporter_test.go ├── exporterhelper │ ├── README.md │ ├── common.go │ ├── common_test.go │ ├── constants.go │ ├── doc.go │ ├── internal │ │ ├── bounded_memory_queue.go │ │ ├── bounded_memory_queue_test.go │ │ ├── persistent_queue.go │ │ ├── persistent_queue_test.go │ │ ├── persistent_storage.go │ │ ├── persistent_storage_batch.go │ │ ├── persistent_storage_batch_test.go │ │ ├── persistent_storage_test.go │ │ ├── producer_consumer_queue.go │ │ └── request.go │ ├── logs.go │ ├── logs_test.go │ ├── metrics.go │ ├── metrics_test.go │ ├── obsreport.go │ ├── obsreport_test.go │ ├── queued_retry.go │ ├── queued_retry_test.go │ ├── traces.go │ └── traces_test.go ├── exportertest │ ├── nop_exporter.go │ └── nop_exporter_test.go ├── go.mod ├── go.sum ├── loggingexporter │ ├── Makefile │ ├── README.md │ ├── config.go │ ├── config_test.go │ ├── doc.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── internal │ │ └── otlptext │ │ │ ├── databuffer.go │ │ │ ├── databuffer_test.go │ │ │ ├── logs.go │ │ │ ├── logs_test.go │ │ │ ├── metrics.go │ │ │ ├── metrics_test.go │ │ │ ├── testdata │ │ │ ├── logs │ │ │ │ ├── embedded_maps.out │ │ │ │ ├── empty.out │ │ │ │ ├── one_record.out │ │ │ │ └── two_records.out │ │ │ ├── metrics │ │ │ │ ├── empty.out │ │ │ │ ├── invalid_metric_type.out │ │ │ │ ├── metrics_with_all_types.out │ │ │ │ └── two_metrics.out │ │ │ └── traces │ │ │ │ ├── empty.out │ │ │ │ └── two_spans.out │ │ │ ├── traces.go │ │ │ └── traces_test.go │ ├── known_sync_error.go │ ├── known_sync_error_other.go │ ├── known_sync_error_windows.go │ ├── logging_exporter.go │ ├── logging_exporter_test.go │ └── testdata │ │ ├── config_loglevel.yaml │ │ ├── config_loglevel_typo.yaml │ │ ├── config_verbosity.yaml │ │ ├── invalid_verbosity_loglevel.yaml │ │ └── loglevel_info.yaml ├── otlpexporter │ ├── Makefile │ ├── README.md │ ├── arrow-design.png │ ├── cfg-schema.yaml │ ├── config.go │ ├── config_test.go │ ├── doc.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── internal │ │ └── arrow │ │ │ ├── common_test.go │ │ │ ├── exporter.go │ │ │ ├── exporter_test.go │ │ │ ├── grpcmock │ │ │ └── credentials.go │ │ │ ├── prioritizer.go │ │ │ ├── stream.go │ │ │ └── stream_test.go │ ├── otlp.go │ ├── otlp_test.go │ └── testdata │ │ ├── config.yaml │ │ ├── test_cert.pem │ │ └── test_key.pem └── otlphttpexporter │ ├── Makefile │ ├── README.md │ ├── config.go │ ├── config_test.go │ ├── doc.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── otlp.go │ ├── otlp_test.go │ └── testdata │ ├── bad_empty_config.yaml │ ├── config.yaml │ └── test_cert.pem ├── extension ├── Makefile ├── README.md ├── auth │ ├── Makefile │ ├── authtest │ │ ├── mock_clientauth.go │ │ └── mock_clientauth_test.go │ ├── client.go │ ├── client_test.go │ ├── doc.go │ ├── go.mod │ ├── go.sum │ ├── server.go │ └── server_test.go ├── ballastextension │ ├── Makefile │ ├── README.md │ ├── config.go │ ├── config_test.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── memory_ballast.go │ ├── memory_ballast_test.go │ └── testdata │ │ └── config.yaml ├── experimental │ └── storage │ │ ├── Makefile │ │ ├── README.md │ │ ├── doc.go │ │ ├── nop_client.go │ │ └── storage.go ├── extension.go ├── extension_test.go ├── extensiontest │ ├── nop_extension.go │ └── nop_extension_test.go ├── go.mod ├── go.sum └── zpagesextension │ ├── Makefile │ ├── README.md │ ├── config.go │ ├── config_test.go │ ├── doc.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── testdata │ └── config.yaml │ ├── zpagesextension.go │ └── zpagesextension_test.go ├── featuregate ├── Makefile ├── README.md ├── flag.go ├── flag_test.go ├── gate.go ├── gate_test.go ├── go.mod ├── go.sum ├── registry.go ├── registry_test.go ├── stage.go └── stage_test.go ├── go.mod ├── go.sum ├── internal ├── buildscripts │ ├── compare-apidiff.sh │ ├── gen-apidiff.sh │ └── gen-certs.sh ├── cgroups │ ├── cgroup.go │ ├── cgroup_test.go │ ├── cgroups.go │ ├── cgroups_test.go │ ├── doc.go │ ├── errors.go │ ├── mountpoint.go │ ├── mountpoint_test.go │ ├── subsys.go │ ├── subsys_test.go │ ├── testdata │ │ ├── cgroups │ │ │ ├── cpu │ │ │ │ ├── cpu.cfs_period_us │ │ │ │ └── cpu.cfs_quota_us │ │ │ ├── empty │ │ │ │ └── cpu.cfs_quota_us │ │ │ ├── invalid │ │ │ │ └── cpu.cfs_quota_us │ │ │ ├── memory │ │ │ │ └── memory.limit_in_bytes │ │ │ ├── undefined-period │ │ │ │ └── cpu.cfs_quota_us │ │ │ ├── undefined │ │ │ │ ├── cpu.cfs_period_us │ │ │ │ └── cpu.cfs_quota_us │ │ │ └── v2 │ │ │ │ ├── empty │ │ │ │ └── memory.max │ │ │ │ ├── invalid │ │ │ │ └── memory.max │ │ │ │ ├── memory │ │ │ │ └── memory.max │ │ │ │ └── undefined │ │ │ │ └── memory.max │ │ └── proc │ │ │ ├── cgroups │ │ │ ├── cgroup │ │ │ └── mountinfo │ │ │ ├── invalid-cgroup │ │ │ └── cgroup │ │ │ ├── invalid-mountinfo │ │ │ └── mountinfo │ │ │ ├── untranslatable │ │ │ ├── cgroup │ │ │ └── mountinfo │ │ │ └── v2 │ │ │ ├── cgroupv1 │ │ │ └── mountinfo │ │ │ ├── cgroupv1v2 │ │ │ └── mountinfo │ │ │ └── cgroupv2 │ │ │ └── mountinfo │ └── util_test.go ├── fanoutconsumer │ ├── logs.go │ ├── logs_test.go │ ├── metrics.go │ ├── metrics_test.go │ ├── traces.go │ └── traces_test.go ├── iruntime │ ├── mem_info.go │ ├── mem_info_test.go │ ├── total_memory_linux.go │ ├── total_memory_linux_test.go │ ├── total_memory_other.go │ └── total_memory_other_test.go ├── netstats │ ├── handler.go │ ├── netstats.go │ └── netstats_test.go ├── obsreportconfig │ ├── obsmetrics │ │ ├── obs_exporter.go │ │ ├── obs_processor.go │ │ ├── obs_receiver.go │ │ ├── obs_scraper.go │ │ └── obsmetrics.go │ ├── obsreportconfig.go │ └── obsreportconfig_test.go ├── sharedcomponent │ ├── sharedcomponent.go │ └── sharedcomponent_test.go ├── testdata │ ├── common.go │ ├── log.go │ ├── metric.go │ ├── resource.go │ └── trace.go ├── testutil │ ├── testutil.go │ └── testutil_test.go └── tools │ ├── Makefile │ ├── empty.go │ ├── go.mod │ ├── go.sum │ ├── jsonschema_patch.sed │ └── tools.go ├── obsreport ├── doc.go ├── obsreport.go ├── obsreport_exporter.go ├── obsreport_processor.go ├── obsreport_receiver.go ├── obsreport_scraper.go ├── obsreport_test.go └── obsreporttest │ ├── obsreporttest.go │ ├── obsreporttest_test.go │ ├── otelprometheuschecker.go │ ├── otelprometheuschecker_test.go │ └── testdata │ └── prometheus_response ├── otelcol ├── collector.go ├── collector_test.go ├── collector_windows.go ├── collector_windows_test.go ├── command.go ├── command_components.go ├── command_components_test.go ├── command_test.go ├── command_validate.go ├── command_validate_test.go ├── config.go ├── config_test.go ├── configprovider.go ├── configprovider_test.go ├── factories.go ├── factories_test.go ├── flags.go ├── flags_test.go ├── internal │ ├── configunmarshaler │ │ ├── configs.go │ │ └── configs_test.go │ └── grpclog │ │ ├── logger.go │ │ └── logger_test.go ├── otelcoltest │ ├── config.go │ ├── config_test.go │ ├── nop_factories.go │ ├── nop_factories_test.go │ └── testdata │ │ └── config.yaml ├── testdata │ ├── otelcol-invalid-components.yaml │ ├── otelcol-invalid.yaml │ ├── otelcol-invalidprop.yaml │ ├── otelcol-noaddress.yaml │ ├── otelcol-nometrics.yaml │ ├── otelcol-nop.yaml │ └── otelcol-validprop.yaml ├── unmarshaler.go └── unmarshaler_test.go ├── pdata ├── Makefile ├── README.md ├── go.mod ├── go.sum ├── internal │ ├── .gitignore │ ├── cmd │ │ └── pdatagen │ │ │ ├── internal │ │ │ ├── base_fields.go │ │ │ ├── base_slices.go │ │ │ ├── base_structs.go │ │ │ ├── packages.go │ │ │ ├── pcommon_package.go │ │ │ ├── plog_package.go │ │ │ ├── plogotlp_package.go │ │ │ ├── pmetric_package.go │ │ │ ├── pmetricotlp_package.go │ │ │ ├── primitive_slice_structs.go │ │ │ ├── ptrace_package.go │ │ │ └── ptraceotlp_package.go │ │ │ └── main.go │ ├── data │ │ ├── bytesid.go │ │ ├── protogen │ │ │ ├── collector │ │ │ │ ├── logs │ │ │ │ │ └── v1 │ │ │ │ │ │ └── logs_service.pb.go │ │ │ │ ├── metrics │ │ │ │ │ └── v1 │ │ │ │ │ │ └── metrics_service.pb.go │ │ │ │ └── trace │ │ │ │ │ └── v1 │ │ │ │ │ └── trace_service.pb.go │ │ │ ├── common │ │ │ │ └── v1 │ │ │ │ │ └── common.pb.go │ │ │ ├── logs │ │ │ │ └── v1 │ │ │ │ │ └── logs.pb.go │ │ │ ├── metrics │ │ │ │ └── v1 │ │ │ │ │ └── metrics.pb.go │ │ │ ├── resource │ │ │ │ └── v1 │ │ │ │ │ └── resource.pb.go │ │ │ └── trace │ │ │ │ └── v1 │ │ │ │ └── trace.pb.go │ │ ├── spanid.go │ │ ├── spanid_test.go │ │ ├── traceid.go │ │ └── traceid_test.go │ ├── generated_wrapper_byteslice.go │ ├── generated_wrapper_float64slice.go │ ├── generated_wrapper_instrumentationscope.go │ ├── generated_wrapper_resource.go │ ├── generated_wrapper_uint64slice.go │ ├── json │ │ ├── attribute.go │ │ ├── attribute_test.go │ │ ├── enum.go │ │ ├── enum_test.go │ │ ├── json.go │ │ ├── number.go │ │ ├── number_test.go │ │ ├── resource.go │ │ ├── resource_test.go │ │ ├── scope.go │ │ └── scope_test.go │ ├── otlp │ │ ├── logs.go │ │ ├── logs_test.go │ │ ├── metrics.go │ │ ├── metrics_test.go │ │ ├── traces.go │ │ └── traces_test.go │ ├── wrapper_logs.go │ ├── wrapper_map.go │ ├── wrapper_metrics.go │ ├── wrapper_slice.go │ ├── wrapper_traces.go │ ├── wrapper_tracestate.go │ └── wrapper_value.go ├── pcommon │ ├── generated_byteslice.go │ ├── generated_byteslice_test.go │ ├── generated_float64slice.go │ ├── generated_float64slice_test.go │ ├── generated_instrumentationscope.go │ ├── generated_instrumentationscope_test.go │ ├── generated_resource.go │ ├── generated_resource_test.go │ ├── generated_uint64slice.go │ ├── generated_uint64slice_test.go │ ├── map.go │ ├── map_test.go │ ├── slice.go │ ├── slice_test.go │ ├── spanid.go │ ├── spanid_test.go │ ├── timestamp.go │ ├── timestamp_test.go │ ├── trace_state.go │ ├── trace_state_test.go │ ├── traceid.go │ ├── traceid_test.go │ ├── value.go │ └── value_test.go ├── plog │ ├── encoding.go │ ├── generated_logrecord.go │ ├── generated_logrecord_test.go │ ├── generated_logrecordslice.go │ ├── generated_logrecordslice_test.go │ ├── generated_resourcelogs.go │ ├── generated_resourcelogs_test.go │ ├── generated_resourcelogsslice.go │ ├── generated_resourcelogsslice_test.go │ ├── generated_scopelogs.go │ ├── generated_scopelogs_test.go │ ├── generated_scopelogsslice.go │ ├── generated_scopelogsslice_test.go │ ├── json.go │ ├── json_test.go │ ├── log_record_flags.go │ ├── log_record_flags_test.go │ ├── logs.go │ ├── logs_test.go │ ├── pb.go │ ├── pb_test.go │ ├── plogotlp │ │ ├── generated_exportpartialsuccess.go │ │ ├── generated_exportpartialsuccess_test.go │ │ ├── grpc.go │ │ ├── grpc_test.go │ │ ├── request.go │ │ ├── request_test.go │ │ ├── response.go │ │ └── response_test.go │ ├── severity_number.go │ └── severity_number_test.go ├── pmetric │ ├── aggregation_temporality.go │ ├── aggregation_temporality_test.go │ ├── encoding.go │ ├── exemplar_value_type.go │ ├── exemplar_value_type_test.go │ ├── generated_exemplar.go │ ├── generated_exemplar_test.go │ ├── generated_exemplarslice.go │ ├── generated_exemplarslice_test.go │ ├── generated_exponentialhistogram.go │ ├── generated_exponentialhistogram_test.go │ ├── generated_exponentialhistogramdatapoint.go │ ├── generated_exponentialhistogramdatapoint_test.go │ ├── generated_exponentialhistogramdatapointbuckets.go │ ├── generated_exponentialhistogramdatapointbuckets_test.go │ ├── generated_exponentialhistogramdatapointslice.go │ ├── generated_exponentialhistogramdatapointslice_test.go │ ├── generated_gauge.go │ ├── generated_gauge_test.go │ ├── generated_histogram.go │ ├── generated_histogram_test.go │ ├── generated_histogramdatapoint.go │ ├── generated_histogramdatapoint_test.go │ ├── generated_histogramdatapointslice.go │ ├── generated_histogramdatapointslice_test.go │ ├── generated_metric.go │ ├── generated_metric_test.go │ ├── generated_metricslice.go │ ├── generated_metricslice_test.go │ ├── generated_numberdatapoint.go │ ├── generated_numberdatapoint_test.go │ ├── generated_numberdatapointslice.go │ ├── generated_numberdatapointslice_test.go │ ├── generated_resourcemetrics.go │ ├── generated_resourcemetrics_test.go │ ├── generated_resourcemetricsslice.go │ ├── generated_resourcemetricsslice_test.go │ ├── generated_scopemetrics.go │ ├── generated_scopemetrics_test.go │ ├── generated_scopemetricsslice.go │ ├── generated_scopemetricsslice_test.go │ ├── generated_sum.go │ ├── generated_sum_test.go │ ├── generated_summary.go │ ├── generated_summary_test.go │ ├── generated_summarydatapoint.go │ ├── generated_summarydatapoint_test.go │ ├── generated_summarydatapointslice.go │ ├── generated_summarydatapointslice_test.go │ ├── generated_summarydatapointvalueatquantile.go │ ├── generated_summarydatapointvalueatquantile_test.go │ ├── generated_summarydatapointvalueatquantileslice.go │ ├── generated_summarydatapointvalueatquantileslice_test.go │ ├── json.go │ ├── json_test.go │ ├── metric_data_point_flags.go │ ├── metric_data_point_flags_test.go │ ├── metric_type.go │ ├── metric_type_test.go │ ├── metrics.go │ ├── metrics_test.go │ ├── number_data_point_value_type.go │ ├── number_data_point_value_type_test.go │ ├── pb.go │ ├── pb_test.go │ └── pmetricotlp │ │ ├── generated_exportpartialsuccess.go │ │ ├── generated_exportpartialsuccess_test.go │ │ ├── grpc.go │ │ ├── grpc_test.go │ │ ├── request.go │ │ ├── request_test.go │ │ ├── response.go │ │ └── response_test.go └── ptrace │ ├── encoding.go │ ├── generated_resourcespans.go │ ├── generated_resourcespans_test.go │ ├── generated_resourcespansslice.go │ ├── generated_resourcespansslice_test.go │ ├── generated_scopespans.go │ ├── generated_scopespans_test.go │ ├── generated_scopespansslice.go │ ├── generated_scopespansslice_test.go │ ├── generated_span.go │ ├── generated_span_test.go │ ├── generated_spanevent.go │ ├── generated_spanevent_test.go │ ├── generated_spaneventslice.go │ ├── generated_spaneventslice_test.go │ ├── generated_spanlink.go │ ├── generated_spanlink_test.go │ ├── generated_spanlinkslice.go │ ├── generated_spanlinkslice_test.go │ ├── generated_spanslice.go │ ├── generated_spanslice_test.go │ ├── generated_status.go │ ├── generated_status_test.go │ ├── json.go │ ├── json_test.go │ ├── pb.go │ ├── pb_test.go │ ├── ptraceotlp │ ├── generated_exportpartialsuccess.go │ ├── generated_exportpartialsuccess_test.go │ ├── grpc.go │ ├── grpc_test.go │ ├── request.go │ ├── request_test.go │ ├── response.go │ └── response_test.go │ ├── span_kind.go │ ├── span_kind_test.go │ ├── status_code.go │ ├── status_code_test.go │ ├── traces.go │ └── traces_test.go ├── processor ├── Makefile ├── README.md ├── batchprocessor │ ├── Makefile │ ├── README.md │ ├── batch_processor.go │ ├── batch_processor_test.go │ ├── config.go │ ├── config_test.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── metrics.go │ ├── metrics_test.go │ ├── splitlogs.go │ ├── splitlogs_test.go │ ├── splitmetrics.go │ ├── splitmetrics_test.go │ ├── splittraces.go │ ├── splittraces_test.go │ └── testdata │ │ └── config.yaml ├── go.mod ├── go.sum ├── memorylimiterprocessor │ ├── Makefile │ ├── README.md │ ├── config.go │ ├── config_test.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── internal │ │ ├── mock_exporter.go │ │ └── mock_receiver.go │ ├── memorylimiter.go │ ├── memorylimiter_test.go │ └── testdata │ │ └── config.yaml ├── processor.go ├── processor_test.go ├── processorhelper │ ├── logs.go │ ├── logs_test.go │ ├── metrics.go │ ├── metrics_test.go │ ├── processor.go │ ├── traces.go │ └── traces_test.go └── processortest │ ├── nop_processor.go │ ├── nop_processor_test.go │ └── shutdown_verifier.go ├── proto_patch.sed ├── receiver ├── Makefile ├── README.md ├── doc.go ├── go.mod ├── go.sum ├── otlpreceiver │ ├── Makefile │ ├── README.md │ ├── config.go │ ├── config.md │ ├── config_test.go │ ├── doc.go │ ├── encoder.go │ ├── factory.go │ ├── factory_test.go │ ├── go.mod │ ├── go.sum │ ├── internal │ │ ├── arrow │ │ │ ├── arrow.go │ │ │ ├── arrow_test.go │ │ │ └── mock │ │ │ │ ├── auth.go │ │ │ │ └── consumer.go │ │ ├── logs │ │ │ ├── otlp.go │ │ │ └── otlp_test.go │ │ ├── metrics │ │ │ ├── otlp.go │ │ │ └── otlp_test.go │ │ └── trace │ │ │ ├── otlp.go │ │ │ └── otlp_test.go │ ├── otlp.go │ ├── otlp_test.go │ ├── otlphttp.go │ └── testdata │ │ ├── arrow_without_grpc.yaml │ │ ├── bad_no_proto_config.yaml │ │ ├── bad_proto_config.yaml │ │ ├── config.yaml │ │ ├── default.yaml │ │ ├── invalid_logs_path.yaml │ │ ├── invalid_metrics_path.yaml │ │ ├── invalid_traces_path.yaml │ │ ├── only_grpc.yaml │ │ ├── only_http.yaml │ │ ├── only_http_empty_map.yaml │ │ ├── only_http_null.yaml │ │ ├── typo_default_proto_config.yaml │ │ └── uds.yaml ├── receiver.go ├── receiver_test.go ├── receivertest │ ├── contract_checker.go │ ├── contract_checker_test.go │ ├── nop_receiver.go │ └── nop_receiver_test.go ├── scrapererror │ ├── doc.go │ ├── partialscrapeerror.go │ ├── partialscrapeerror_test.go │ ├── scrapeerror.go │ └── scrapeerror_test.go └── scraperhelper │ ├── doc.go │ ├── scraper.go │ ├── scrapercontroller.go │ ├── scrapercontroller_test.go │ ├── settings.go │ └── settings_test.go ├── renovate.json ├── semconv ├── Makefile ├── README.md ├── go.mod ├── go.sum ├── semconv_test.go ├── template.j2 ├── v1.10.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.11.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.12.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.13.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.16.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.17.0 │ ├── generated_event.go │ ├── generated_resource.go │ ├── generated_trace.go │ └── schema.go ├── v1.18.0 │ ├── generated_event.go │ ├── generated_resource.go │ ├── generated_trace.go │ └── schema.go ├── v1.5.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.6.1 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.7.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── v1.8.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go └── v1.9.0 │ ├── generated_resource.go │ ├── generated_trace.go │ ├── nonstandard.go │ └── schema.go ├── service ├── README.md ├── config.go ├── config_test.go ├── extensions │ ├── config.go │ ├── extensions.go │ └── extensions_test.go ├── host.go ├── internal │ ├── capabilityconsumer │ │ ├── capabilities.go │ │ └── capabilities_test.go │ ├── components │ │ ├── components.go │ │ ├── components_test.go │ │ ├── host_wrapper.go │ │ ├── host_wrapper_test.go │ │ └── loggers.go │ ├── graph │ │ ├── graph.go │ │ ├── graph_test.go │ │ ├── nodes.go │ │ └── zpages.go │ ├── proctelemetry │ │ ├── config.go │ │ ├── config_test.go │ │ ├── process_telemetry.go │ │ └── process_telemetry_test.go │ ├── testcomponents │ │ ├── example_connector.go │ │ ├── example_connector_test.go │ │ ├── example_exporter.go │ │ ├── example_exporter_test.go │ │ ├── example_processor.go │ │ ├── example_processor_test.go │ │ ├── example_receiver.go │ │ ├── example_receiver_test.go │ │ ├── example_router.go │ │ ├── example_router_test.go │ │ └── stateful_component.go │ └── zpages │ │ ├── templates.go │ │ ├── templates │ │ ├── component_header.html │ │ ├── extensions_table.html │ │ ├── features_table.html │ │ ├── page_footer.html │ │ ├── page_header.html │ │ ├── pipelines_table.html │ │ └── properties_table.html │ │ └── templates_test.go ├── pipelines │ ├── config.go │ └── config_test.go ├── service.go ├── service_test.go ├── telemetry.go ├── telemetry │ ├── config.go │ ├── config_test.go │ ├── generated_config.go │ ├── otel_trace_sampler.go │ └── telemetry.go ├── telemetry_test.go └── zpages.go └── versions.yaml /.chloggen/TEMPLATE.yaml: -------------------------------------------------------------------------------- 1 | # Use this changelog template to create an entry for release notes. 2 | 3 | # One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' 4 | change_type: 5 | 6 | # The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver) 7 | component: 8 | 9 | # A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). 10 | note: 11 | 12 | # One or more tracking issues or pull requests related to the change 13 | issues: [] 14 | 15 | # (Optional) One or more lines of additional information to render under the primary note. 16 | # These lines will be padded with 2 spaces and then inserted directly into the document. 17 | # Use pipe (|) for multiline entries. 18 | subtext: 19 | 20 | # Optional: The change log or logs in which this entry should be included. 21 | # e.g. '[user]' or '[user, api]' 22 | # Include 'user' if the change is relevant to end users. 23 | # Include 'api' if there is a change to a library API. 24 | # Default: '[user]' 25 | change_logs: [] -------------------------------------------------------------------------------- /.chloggen/config.yaml: -------------------------------------------------------------------------------- 1 | # The directory that stores individual changelog entries. 2 | # Each entry is stored in a dedicated yaml file. 3 | # - 'chloggen new' will copy the 'template_yaml' to this directory as a new entry file. 4 | # - 'chloggen validate' will validate that all entry files are valid. 5 | # - 'chloggen update' will read and delete all entry files in this directory, and update 'changelog_md'. 6 | # Specify as relative path from root of repo. 7 | # (Optional) Default: .chloggen 8 | entries_dir: .chloggen 9 | 10 | # This file is used as the input for individual changelog entries. 11 | # Specify as relative path from root of repo. 12 | # (Optional) Default: .chloggen/TEMPLATE.yaml 13 | template_yaml: .chloggen/TEMPLATE.yaml 14 | 15 | # The CHANGELOG file or files to which 'chloggen update' will write new entries 16 | # (Optional) Default filename: CHANGELOG.md 17 | change_logs: 18 | user: CHANGELOG.md 19 | api: CHANGELOG-API.md 20 | 21 | # The default change_log or change_logs to which an entry should be added. 22 | # If 'change_logs' is specified in this file, and no value is specified for 'default_change_logs', 23 | # then 'change_logs' MUST be specified in every entry file. 24 | default_change_logs: [user] 25 | -------------------------------------------------------------------------------- /.chloggen/use-sync/atomic.yaml: -------------------------------------------------------------------------------- 1 | # One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' 2 | change_type: enhancement 3 | 4 | # The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver) 5 | component: all 6 | 7 | # A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). 8 | note: "replacing uber-go/atomic by sync/atomic" 9 | 10 | # One or more tracking issues or pull requests related to the change 11 | issues: [7160] 12 | 13 | # (Optional) One or more lines of additional information to render under the primary note. 14 | # These lines will be padded with 2 spaces and then inserted directly into the document. 15 | # Use pipe (|) for multiline entries. 16 | subtext: 17 | -------------------------------------------------------------------------------- /.codecov.yml: -------------------------------------------------------------------------------- 1 | codecov: 2 | branch: main 3 | # only use the latest copy on main branch 4 | strict_yaml_branch: main 5 | 6 | coverage: 7 | precision: 2 8 | round: down 9 | range: "80...100" 10 | status: 11 | project: 12 | default: 13 | enabled: yes 14 | target: 90% 15 | patch: 16 | default: 17 | enabled: yes 18 | target: 95% 19 | 20 | ignore: 21 | - "pdata/internal/data/protogen/**/*" 22 | -------------------------------------------------------------------------------- /.github/CODEOWNERS: -------------------------------------------------------------------------------- 1 | ##################################################### 2 | # 3 | # List of approvers for OpenTelemetry Collector 4 | # 5 | ##################################################### 6 | # 7 | # Learn about membership in OpenTelemetry community: 8 | # https://github.com/open-telemetry/community/blob/main/community-membership.md 9 | # 10 | # 11 | # Learn about CODEOWNERS file format: 12 | # https://help.github.com/en/articles/about-code-owners 13 | # 14 | 15 | * @open-telemetry/collector-approvers 16 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: bug 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Describe the bug** 11 | A clear and concise description of what the bug is. 12 | 13 | **Steps to reproduce** 14 | If possible, provide a recipe for reproducing the error. 15 | 16 | **What did you expect to see?** 17 | A clear and concise description of what you expected to see. 18 | 19 | **What did you see instead?** 20 | A clear and concise description of what you saw instead. 21 | 22 | **What version did you use?** 23 | Version: (e.g., `v0.4.0`, `1eb551b`, etc) 24 | 25 | **What config did you use?** 26 | Config: (e.g. the yaml config file) 27 | 28 | **Environment** 29 | OS: (e.g., "Ubuntu 20.04") 30 | Compiler(if manually compiled): (e.g., "go 14.2") 31 | 32 | **Additional context** 33 | Add any other context about the problem here. 34 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: feature request 6 | assignees: '' 7 | 8 | --- 9 | 10 | ## Important (read before submitting) 11 | We are currently preparing for the upcoming 1.0 GA release. Feature requests that are not aligned with 12 | the current roadmap https://github.com/open-telemetry/opentelemetry-collector/blob/main/docs/roadmap.md 13 | and are not aimed at stabilizing and preparing the Collector for the release will not be prioritized. 14 | 15 | _Delete this paragraph before submitting._ 16 | 17 | **Is your feature request related to a problem? Please describe.** 18 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 19 | 20 | **Describe the solution you'd like** 21 | A clear and concise description of what you want to happen. 22 | 23 | **Describe alternatives you've considered** 24 | A clear and concise description of any alternative solutions or features you've considered. 25 | 26 | **Additional context** 27 | Add any other context or screenshots about the feature request here. 28 | 29 | _Please delete paragraphs that you did not use before submitting._ 30 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/release.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Release 3 | about: Create an issue for releasing new versions 4 | title: 'Release stable vY.Y.Y and beta vX.X.X' 5 | labels: release 6 | assignees: '' 7 | 8 | --- 9 | 10 | Like #4522, but for vX.X.X 11 | 12 | **Performed by collector release manager** 13 | 14 | - [ ] Prepare stable core release vY.Y.Y 15 | - [ ] Tag and release stable core vY.Y.Y 16 | - [ ] Prepare beta core release vX.X.X 17 | - [ ] Tag and release beta core vX.X.X 18 | - [ ] Prepare contrib release vX.X.X 19 | - [ ] Tag and release contrib vX.X.X 20 | - [ ] Prepare otelcol-releases vX.X.X 21 | - [ ] Release binaries and container images vX.X.X 22 | 23 | **Performed by operator maintainers** 24 | 25 | - [ ] Release the operator vX.X.X 26 | 27 | **Performed by helm chart maintainers** 28 | 29 | - [ ] Update the opentelemetry-collector helm chart to use vX.X.X docker image 30 | -------------------------------------------------------------------------------- /.github/pull_request_template.md: -------------------------------------------------------------------------------- 1 | ## Important (read before submitting) 2 | We are currently preparing for the upcoming 1.0 GA release. Pull requests that are not aligned with 3 | the current roadmap https://github.com/open-telemetry/opentelemetry-collector/blob/main/docs/roadmap.md 4 | and are not aimed at stabilizing and preparing the Collector for the release will not be accepted. 5 | 6 | _Delete this paragraph before submitting._ 7 | 8 | **Description:** 11 | 12 | **Link to tracking Issue:** 13 | 14 | **Testing:** < Describe what testing was performed and which tests were added.> 15 | 16 | **Documentation:** < Describe the documentation added.> 17 | 18 | _Please delete paragraphs that you did not use before submitting._ 19 | -------------------------------------------------------------------------------- /.github/workflows/build-and-test-windows.yaml: -------------------------------------------------------------------------------- 1 | name: build-and-test-windows 2 | on: 3 | push: 4 | branches: [ main ] 5 | tags: 6 | - 'v[0-9]+.[0-9]+.[0-9]+*' 7 | pull_request: 8 | 9 | concurrency: 10 | group: ${{ github.workflow }}-${{ github.head_ref }} 11 | cancel-in-progress: true 12 | 13 | jobs: 14 | windows-unittest: 15 | runs-on: windows-latest 16 | steps: 17 | - name: Checkout Repo 18 | uses: actions/checkout@v3 19 | - name: Setup Go 20 | uses: actions/setup-go@v4 21 | with: 22 | go-version: ~1.20.7 23 | - name: Cache Go 24 | uses: actions/cache@v3 25 | env: 26 | cache-name: cache-go-modules 27 | with: 28 | path: | 29 | ~\go\pkg\mod 30 | ~\AppData\Local\go-build 31 | key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} 32 | - name: Run Unit Tests 33 | run: make gotest 34 | -------------------------------------------------------------------------------- /.github/workflows/builder-integration-test.yaml: -------------------------------------------------------------------------------- 1 | name: Builder - Integration tests 2 | 3 | on: 4 | # on changes to the main branch touching the builder 5 | push: 6 | branches: [ main ] 7 | 8 | # on PRs touching the builder 9 | pull_request: 10 | branches: [ main ] 11 | 12 | # once a day at 6:17 AM UTC 13 | schedule: 14 | - cron: '17 6 * * *' 15 | 16 | # manual execution 17 | workflow_dispatch: 18 | 19 | concurrency: 20 | group: ${{ github.workflow }}-${{ github.head_ref }} 21 | cancel-in-progress: true 22 | 23 | jobs: 24 | integration-test: 25 | name: Integration test 26 | runs-on: ubuntu-latest 27 | steps: 28 | - name: Checkout Repo 29 | uses: actions/checkout@v3 30 | - name: Setup Go 31 | uses: actions/setup-go@v4 32 | with: 33 | go-version: ~1.20.7 34 | - name: Test 35 | run: make builder-integration-test 36 | -------------------------------------------------------------------------------- /.github/workflows/check_links_config.json: -------------------------------------------------------------------------------- 1 | { 2 | "ignorePatterns": [ 3 | { 4 | "pattern": "http(s)?://\\d+\\.\\d+\\.\\d+\\.\\d+" 5 | }, 6 | { 7 | "pattern": "http(s)?://localhost" 8 | }, 9 | { 10 | "pattern": "http(s)?://example.com" 11 | } 12 | ], 13 | "aliveStatusCodes": [429, 200], 14 | "httpHeaders": [ 15 | { 16 | "urls": ["https://docs.github.com/"], 17 | "headers": { 18 | "Accept-Encoding": "zstd, br, gzip, deflate" 19 | } 20 | } 21 | ] 22 | } 23 | -------------------------------------------------------------------------------- /.github/workflows/codeql-analysis.yml: -------------------------------------------------------------------------------- 1 | name: "CodeQL Analysis" 2 | on: 3 | push: 4 | branches: [ main ] 5 | pull_request: 6 | 7 | concurrency: 8 | group: ${{ github.workflow }}-${{ github.head_ref }} 9 | cancel-in-progress: true 10 | 11 | jobs: 12 | CodeQL-Build: 13 | runs-on: ubuntu-latest 14 | 15 | steps: 16 | - name: Checkout repository 17 | uses: actions/checkout@v3 18 | 19 | - name: Setup Go 20 | uses: actions/setup-go@v4 21 | with: 22 | go-version: ~1.20.7 23 | 24 | # Initializes the CodeQL tools for scanning. 25 | - name: Initialize CodeQL 26 | uses: github/codeql-action/init@v2 27 | with: 28 | languages: go 29 | 30 | - name: Autobuild 31 | uses: github/codeql-action/autobuild@v2 32 | 33 | - name: Perform CodeQL Analysis 34 | uses: github/codeql-action/analyze@v2 35 | -------------------------------------------------------------------------------- /.github/workflows/contrib-tests.yml: -------------------------------------------------------------------------------- 1 | name: contrib-tests 2 | on: 3 | push: 4 | branches: [ main ] 5 | tags: 6 | - v[0-9]+.[0-9]+.[0-9]+.* 7 | pull_request: 8 | types: [opened, ready_for_review, synchronize, reopened, labeled, unlabeled] 9 | branches: [ main ] 10 | 11 | concurrency: 12 | group: ${{ github.workflow }}-${{ github.head_ref }} 13 | cancel-in-progress: true 14 | 15 | jobs: 16 | contrib_tests: 17 | runs-on: ubuntu-latest 18 | if: ${{ !contains(github.event.pull_request.labels.*.name, 'Skip Contrib Tests') }} 19 | 20 | steps: 21 | - name: Checkout Repo 22 | uses: actions/checkout@v3 23 | - name: Setup Go 24 | uses: actions/setup-go@v4 25 | with: 26 | go-version: ~1.20.7 27 | - name: Run Contrib Tests 28 | run: | 29 | contrib_path=/tmp/opentelemetry-collector-contrib 30 | git clone https://github.com/open-telemetry/opentelemetry-collector-contrib.git $contrib_path 31 | make CONTRIB_PATH=$contrib_path SKIP_RESTORE_CONTRIB=true check-contrib 32 | -------------------------------------------------------------------------------- /.github/workflows/create-dependabot-pr.yml: -------------------------------------------------------------------------------- 1 | name: Automation - Dependabot PR 2 | 3 | on: 4 | workflow_dispatch: 5 | 6 | jobs: 7 | create-pr: 8 | runs-on: ubuntu-latest 9 | steps: 10 | - uses: actions/checkout@v3 11 | - name: Setup Go 12 | uses: actions/setup-go@v4 13 | with: 14 | go-version: ~1.20.7 15 | - name: Run dependabot-pr.sh 16 | run: ./.github/workflows/scripts/dependabot-pr.sh 17 | env: 18 | GITHUB_TOKEN: ${{ secrets.OPENTELEMETRYBOT_GITHUB_TOKEN }} 19 | -------------------------------------------------------------------------------- /.github/workflows/milestone-add-to-pr.yml: -------------------------------------------------------------------------------- 1 | # This action adds the "next release" milestone to a pull request 2 | # when it is merged 3 | 4 | name: 'Project: Add PR to Milestone' 5 | on: 6 | pull_request_target: 7 | types: 8 | - closed 9 | 10 | jobs: 11 | update-pr: 12 | if: github.event.pull_request.merged 13 | runs-on: ubuntu-latest 14 | steps: 15 | - uses: actions/github-script@v6 16 | with: 17 | script: | 18 | const milestones = await github.rest.issues.listMilestones({ 19 | owner: context.repo.owner, 20 | repo: context.repo.repo, 21 | state: "open" 22 | }) 23 | for (const milestone of milestones.data) { 24 | if (milestone.title == "next release") { 25 | await github.rest.issues.update({ 26 | owner: context.repo.owner, 27 | repo: context.repo.repo, 28 | issue_number: context.issue.number, 29 | milestone: milestone.number 30 | }); 31 | return 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /.github/workflows/perf.yml: -------------------------------------------------------------------------------- 1 | name: Automation - Performance 2 | 3 | on: 4 | push: 5 | branches: [main] 6 | 7 | jobs: 8 | runperf: 9 | runs-on: ubuntu-latest 10 | steps: 11 | - uses: actions/checkout@v3 12 | 13 | - name: Setup Go 14 | uses: actions/setup-go@v4 15 | with: 16 | go-version: ~1.20.7 17 | 18 | - name: Run benchmark 19 | run: make gobenchmark 20 | 21 | # Disabling until fine-grained permissions token enabled for the 22 | # repository 23 | #- name: Store benchmark result 24 | # uses: benchmark-action/github-action-benchmark@v1 25 | # with: 26 | # tool: 'go' 27 | # output-file-path: benchmarks.txt 28 | # gh-pages-branch: gh-pages 29 | # auto-push: true 30 | # github-token: ${{ secrets.GITHUB_TOKEN }} 31 | # benchmark-data-dir-path: "docs/dev/bench" 32 | -------------------------------------------------------------------------------- /.github/workflows/scripts/release-check-blockers.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -ex 2 | # 3 | # Copyright The OpenTelemetry Authors 4 | # SPDX-License-Identifier: Apache-2.0 5 | 6 | BLOCKERS=$( gh issue list --search "label:release:blocker" --json url --jq '.[].url' --repo "${REPO}" ) 7 | if [ "${BLOCKERS}" != "" ]; then 8 | echo "Release blockers in ${REPO} repo: ${BLOCKERS}" 9 | exit 1 10 | fi 11 | -------------------------------------------------------------------------------- /.github/workflows/scripts/release-check-build-status.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -ex 2 | # 3 | # Copyright The OpenTelemetry Authors 4 | # SPDX-License-Identifier: Apache-2.0 5 | 6 | BRANCH=main 7 | WORKFLOW=build-and-test 8 | 9 | RESULT=$(gh run list --branch "${BRANCH}" --json status --jq '[.[] | select(.status != "queued" and .status != "in_progress")][0].status' --workflow "${WORKFLOW}" --repo "${REPO}" ) 10 | if [ "${RESULT}" != "completed" ]; then 11 | echo "Build status in ${REPO} is not completed: ${RESULT}" 12 | gh run list --branch "${BRANCH}" --json status,url --jq '[.[] | select(.status != "queued" and .status != "in_progress")][0].url' --workflow "${WORKFLOW}" --repo "${REPO}" 13 | exit 1 14 | fi 15 | -------------------------------------------------------------------------------- /.github/workflows/shellcheck.yml: -------------------------------------------------------------------------------- 1 | name: Shellcheck lint 2 | on: 3 | push: 4 | branches: [ main ] 5 | pull_request: 6 | branches: [ main ] 7 | 8 | jobs: 9 | shellcheck: 10 | name: Shellcheck 11 | runs-on: ubuntu-latest 12 | steps: 13 | - uses: actions/checkout@v3 14 | - name: Run ShellCheck 15 | uses: ludeeus/action-shellcheck@2.0.0 16 | -------------------------------------------------------------------------------- /.github/workflows/stale-pr.yaml: -------------------------------------------------------------------------------- 1 | name: "Close stale pull requests" 2 | on: 3 | schedule: 4 | - cron: "12 3 * * *" # arbitrary time not to DDOS GitHub 5 | 6 | jobs: 7 | stale: 8 | runs-on: ubuntu-latest 9 | steps: 10 | - uses: actions/stale@v8 11 | with: 12 | repo-token: ${{ secrets.GITHUB_TOKEN }} 13 | stale-pr-message: 'This PR was marked stale due to lack of activity. It will be closed in 14 days.' 14 | close-pr-message: 'Closed as inactive. Feel free to reopen if this PR is still being worked on.' 15 | days-before-pr-stale: 14 16 | days-before-issue-stale: 730 17 | days-before-pr-close: 14 18 | days-before-issue-close: 30 19 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | bin/ 2 | dist/ 3 | .tools/ 4 | 5 | # GoLand IDEA 6 | /.idea/ 7 | *.iml 8 | 9 | # VS Code 10 | .vscode/ 11 | .devcontainer/ 12 | 13 | # Emacs 14 | *~ 15 | \#*\# 16 | 17 | # Miscellaneous files 18 | *.sw[op] 19 | *.DS_Store 20 | 21 | # Coverage 22 | coverage/* 23 | coverage.txt 24 | 25 | # Benchmarks 26 | benchmarks.txt 27 | 28 | # Wix 29 | *.wixobj 30 | *.wixpdb 31 | 32 | # golang 33 | go.work* 34 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/.gitmodules -------------------------------------------------------------------------------- /CHANGELOG-API.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Go API Changelog 4 | 5 | This changelog includes only developer-facing changes. 6 | If you are looking for user-facing changes, check out [CHANGELOG.md](./CHANGELOG.md). 7 | 8 | 9 | 10 | ## v0.83.0 11 | 12 | ### 🛑 Breaking changes 🛑 13 | 14 | - `all`: Remove go 1.19 support, bump minimum to go 1.20 and add testing for 1.21 (#8207) 15 | 16 | ### 💡 Enhancements 💡 17 | 18 | - `changelog`: Generate separate changelogs for end users and package consumers (#8153) 19 | -------------------------------------------------------------------------------- /CODEOWNERS: -------------------------------------------------------------------------------- 1 | ##################################################### 2 | # 3 | # List of approvers for this repository 4 | # 5 | ##################################################### 6 | # 7 | # Learn about membership in OpenTelemetry community: 8 | # https://github.com/open-telemetry/community/blob/main/community-membership.md 9 | # 10 | # 11 | # Learn about CODEOWNERS file format: 12 | # https://help.github.com/en/articles/about-code-owners 13 | # 14 | 15 | * @lquerel @jmacd 16 | 17 | CODEOWNERS @lquerel @jmacd 18 | -------------------------------------------------------------------------------- /cmd/builder/.goreleaser.yml: -------------------------------------------------------------------------------- 1 | before: 2 | hooks: 3 | - go mod download 4 | monorepo: 5 | tag_prefix: cmd/builder/ 6 | dir: cmd/builder 7 | builds: 8 | - flags: 9 | - -trimpath 10 | ldflags: 11 | - -s -w -X go.opentelemetry.io/collector/cmd/builder/internal.version={{.Version}} -X go.opentelemetry.io/collector/cmd/builder/internal.date={{.Date}} 12 | env: 13 | - CGO_ENABLED=0 14 | goos: 15 | - linux 16 | - windows 17 | - darwin 18 | goarch: 19 | - amd64 20 | - arm64 21 | - ppc64le 22 | ignore: 23 | - goos: windows 24 | goarch: arm64 25 | binary: ocb 26 | release: 27 | github: 28 | owner: open-telemetry 29 | name: opentelemetry-collector 30 | header: | 31 | ### Images and binaries here: https://github.com/open-telemetry/opentelemetry-collector-releases/releases/tag/{{ .Tag }} 32 | archives: 33 | - format: binary 34 | checksum: 35 | name_template: "checksums.txt" 36 | snapshot: 37 | name_template: "{{ .Tag }}-next" 38 | changelog: 39 | skip: true 40 | -------------------------------------------------------------------------------- /cmd/builder/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | 3 | .PHONY: ocb 4 | ocb: 5 | GO111MODULE=on CGO_ENABLED=0 $(GOCMD) build -trimpath -o ../../bin/ocb_$(GOOS)_$(GOARCH) . 6 | 7 | # Generate the default build config from otelcorecol, by removing the 8 | # "replaces" stanza, which is assumed to be at the end of the file. 9 | # 10 | # The default config file is checked in so that `go install` will work 11 | # and so that non-unix builds don't need sed to be installed. 12 | .PHONY: config 13 | config: internal/config/default.yaml 14 | sed '-e/replaces:/,$$d' <../otelcorecol/builder-config.yaml > internal/config/default.yaml 15 | -------------------------------------------------------------------------------- /cmd/builder/RELEASE.md: -------------------------------------------------------------------------------- 1 | # Releasing the OpenTelemetry Collector Builder 2 | 3 | This project uses [`goreleaser`](https://github.com/goreleaser/goreleaser) to manage the release of new versions. 4 | 5 | To release a new version, simply add a tag named `vX.Y.Z`, like: 6 | 7 | ``` 8 | git tag -a v0.1.1 -m "Release v0.1.1" 9 | git push upstream v0.1.1 10 | ``` 11 | 12 | A new GitHub workflow should be started, and at the end, a GitHub release should have been created, similar with the ["Release v0.56.0"](https://github.com/open-telemetry/opentelemetry-collector/releases/tag/cmd%2Fbuilder%2Fv0.56.0). -------------------------------------------------------------------------------- /cmd/builder/header.txt: -------------------------------------------------------------------------------- 1 | Copyright The OpenTelemetry Authors 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. -------------------------------------------------------------------------------- /cmd/builder/internal/builder/templates/main.go.tmpl: -------------------------------------------------------------------------------- 1 | // Code generated by "go.opentelemetry.io/collector/cmd/builder". DO NOT EDIT. 2 | 3 | // Program {{ .Distribution.Name }} is an OpenTelemetry Collector binary. 4 | package main 5 | 6 | import ( 7 | "log" 8 | "go.opentelemetry.io/collector/component" 9 | "go.opentelemetry.io/collector/otelcol" 10 | ) 11 | 12 | func main() { 13 | factories, err := components() 14 | if err != nil { 15 | log.Fatalf("failed to build components: %v", err) 16 | } 17 | 18 | info := component.BuildInfo{ 19 | Command: "{{ .Distribution.Name }}", 20 | Description: "{{ .Distribution.Description }}", 21 | Version: "{{ .Distribution.Version }}", 22 | } 23 | 24 | if err := run(otelcol.CollectorSettings{BuildInfo: info, Factories: factories}); err != nil { 25 | log.Fatal(err) 26 | } 27 | } 28 | 29 | func runInteractive(params otelcol.CollectorSettings) error { 30 | cmd := otelcol.NewCommand(params) 31 | if err := cmd.Execute(); err != nil { 32 | log.Fatalf("collector server run finished with error: %v", err) 33 | } 34 | 35 | return nil 36 | } 37 | -------------------------------------------------------------------------------- /cmd/builder/internal/builder/templates/main_others.go.tmpl: -------------------------------------------------------------------------------- 1 | // Code generated by "go.opentelemetry.io/collector/cmd/builder". DO NOT EDIT. 2 | 3 | //go:build !windows 4 | // +build !windows 5 | 6 | package main 7 | 8 | import "go.opentelemetry.io/collector/otelcol" 9 | 10 | func run(params otelcol.CollectorSettings) error { 11 | return runInteractive(params) 12 | } 13 | -------------------------------------------------------------------------------- /cmd/builder/internal/config/default.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package config // import "go.opentelemetry.io/collector/cmd/builder/internal/config" 5 | 6 | import ( 7 | "embed" 8 | 9 | "github.com/knadh/koanf/providers/fs" 10 | "github.com/knadh/koanf/v2" 11 | ) 12 | 13 | //go:embed *.yaml 14 | var configs embed.FS 15 | 16 | // DefaultProvider returns a koanf.Provider that provides the default build 17 | // configuration file. This is the same configuration that otelcorecol is 18 | // built with. 19 | func DefaultProvider() koanf.Provider { 20 | return fs.Provider(configs, "default.yaml") 21 | } 22 | -------------------------------------------------------------------------------- /cmd/builder/internal/config/default.yaml: -------------------------------------------------------------------------------- 1 | dist: 2 | module: go.opentelemetry.io/collector/cmd/otelcorecol 3 | name: otelcorecol 4 | description: Local OpenTelemetry Collector binary, testing only. 5 | version: 0.83.0-dev 6 | otelcol_version: 0.83.0 7 | 8 | receivers: 9 | - gomod: go.opentelemetry.io/collector/receiver/otlpreceiver v0.83.0 10 | exporters: 11 | - gomod: go.opentelemetry.io/collector/exporter/loggingexporter v0.83.0 12 | - gomod: go.opentelemetry.io/collector/exporter/otlpexporter v0.83.0 13 | - gomod: go.opentelemetry.io/collector/exporter/otlphttpexporter v0.83.0 14 | extensions: 15 | - gomod: go.opentelemetry.io/collector/extension/ballastextension v0.83.0 16 | - gomod: go.opentelemetry.io/collector/extension/zpagesextension v0.83.0 17 | processors: 18 | - gomod: go.opentelemetry.io/collector/processor/batchprocessor v0.83.0 19 | - gomod: go.opentelemetry.io/collector/processor/memorylimiterprocessor v0.83.0 20 | connectors: 21 | - gomod: go.opentelemetry.io/collector/connector/forwardconnector v0.83.0 22 | 23 | -------------------------------------------------------------------------------- /cmd/builder/internal/version.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/cmd/builder/internal" 5 | 6 | import ( 7 | "fmt" 8 | 9 | "github.com/spf13/cobra" 10 | ) 11 | 12 | var ( 13 | version = "dev" 14 | date = "unknown" 15 | ) 16 | 17 | func versionCommand() *cobra.Command { 18 | return &cobra.Command{ 19 | Use: "version", 20 | Short: "Version of ocb", 21 | Long: "Prints the version of the ocb binary", 22 | Run: func(cmd *cobra.Command, args []string) { 23 | cmd.Println(fmt.Sprintf("%s version %s", cmd.Parent().Name(), version)) 24 | }, 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /cmd/builder/main.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package main 5 | 6 | import ( 7 | "github.com/spf13/cobra" 8 | 9 | "go.opentelemetry.io/collector/cmd/builder/internal" 10 | ) 11 | 12 | func main() { 13 | cmd, err := internal.Command() 14 | cobra.CheckErr(err) 15 | cobra.CheckErr(cmd.Execute()) 16 | } 17 | -------------------------------------------------------------------------------- /cmd/builder/test/README.md: -------------------------------------------------------------------------------- 1 | # Testing for the OpenTelemetry Collector Builder 2 | 3 | This is a set of end-to-end tests for the builder. As such, it includes only positive tests, based on the manifest files in this directory. Each manifest is expected to be in a working state and should yield an OpenTelemetry Collector instance that is ready within a time interval. "Ready" is defined by calling its healthcheck endpoint. 4 | -------------------------------------------------------------------------------- /cmd/builder/test/core.otel.yaml: -------------------------------------------------------------------------------- 1 | extensions: 2 | zpages: 3 | 4 | receivers: 5 | otlp: 6 | protocols: 7 | grpc: 8 | 9 | processors: 10 | 11 | exporters: 12 | logging: 13 | 14 | service: 15 | extensions: [zpages] 16 | pipelines: 17 | traces: 18 | receivers: 19 | - otlp 20 | processors: [] 21 | exporters: 22 | - logging 23 | -------------------------------------------------------------------------------- /cmd/builder/test/default.otel.yaml: -------------------------------------------------------------------------------- 1 | extensions: 2 | zpages: 3 | 4 | receivers: 5 | otlp: 6 | protocols: 7 | grpc: 8 | 9 | processors: 10 | 11 | exporters: 12 | logging: 13 | 14 | service: 15 | extensions: [zpages] 16 | pipelines: 17 | traces: 18 | receivers: 19 | - otlp 20 | processors: [] 21 | exporters: 22 | - logging 23 | -------------------------------------------------------------------------------- /cmd/otelcorecol/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /cmd/otelcorecol/main.go: -------------------------------------------------------------------------------- 1 | // Code generated by "go.opentelemetry.io/collector/cmd/builder". DO NOT EDIT. 2 | 3 | // Program otelcorecol is an OpenTelemetry Collector binary. 4 | package main 5 | 6 | import ( 7 | "log" 8 | 9 | "go.opentelemetry.io/collector/component" 10 | "go.opentelemetry.io/collector/otelcol" 11 | ) 12 | 13 | func main() { 14 | factories, err := components() 15 | if err != nil { 16 | log.Fatalf("failed to build components: %v", err) 17 | } 18 | 19 | info := component.BuildInfo{ 20 | Command: "otelcorecol", 21 | Description: "Local OpenTelemetry Collector binary, testing only.", 22 | Version: "0.83.0-dev", 23 | } 24 | 25 | if err := run(otelcol.CollectorSettings{BuildInfo: info, Factories: factories}); err != nil { 26 | log.Fatal(err) 27 | } 28 | } 29 | 30 | func runInteractive(params otelcol.CollectorSettings) error { 31 | cmd := otelcol.NewCommand(params) 32 | if err := cmd.Execute(); err != nil { 33 | log.Fatalf("collector server run finished with error: %v", err) 34 | } 35 | 36 | return nil 37 | } 38 | -------------------------------------------------------------------------------- /cmd/otelcorecol/main_others.go: -------------------------------------------------------------------------------- 1 | // Code generated by "go.opentelemetry.io/collector/cmd/builder". DO NOT EDIT. 2 | 3 | //go:build !windows 4 | // +build !windows 5 | 6 | package main 7 | 8 | import "go.opentelemetry.io/collector/otelcol" 9 | 10 | func run(params otelcol.CollectorSettings) error { 11 | return runInteractive(params) 12 | } 13 | -------------------------------------------------------------------------------- /component/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /component/build_info.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package component // import "go.opentelemetry.io/collector/component" 5 | 6 | // BuildInfo is the information that is logged at the application start and 7 | // passed into each component. This information can be overridden in custom build. 8 | type BuildInfo struct { 9 | // Command is the executable file name, e.g. "otelcol". 10 | Command string 11 | 12 | // Description is the full name of the collector, e.g. "OpenTelemetry Collector". 13 | Description string 14 | 15 | // Version string. 16 | Version string 17 | } 18 | 19 | // NewDefaultBuildInfo returns a default BuildInfo. 20 | func NewDefaultBuildInfo() BuildInfo { 21 | return BuildInfo{ 22 | Command: "otelcol", 23 | Description: "OpenTelemetry Collector", 24 | Version: "latest", 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /component/component_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package component 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestStabilityLevelString(t *testing.T) { 13 | assert.EqualValues(t, "Undefined", StabilityLevelUndefined.String()) 14 | assert.EqualValues(t, "Unmaintained", StabilityLevelUnmaintained.String()) 15 | assert.EqualValues(t, "Deprecated", StabilityLevelDeprecated.String()) 16 | assert.EqualValues(t, "Development", StabilityLevelDevelopment.String()) 17 | assert.EqualValues(t, "Alpha", StabilityLevelAlpha.String()) 18 | assert.EqualValues(t, "Beta", StabilityLevelBeta.String()) 19 | assert.EqualValues(t, "Stable", StabilityLevelStable.String()) 20 | assert.EqualValues(t, "", StabilityLevel(100).String()) 21 | } 22 | -------------------------------------------------------------------------------- /component/componenttest/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package componenttest define types and functions used to help test packages 5 | // implementing the component package interfaces. 6 | package componenttest // import "go.opentelemetry.io/collector/component/componenttest" 7 | -------------------------------------------------------------------------------- /component/componenttest/nop_host.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package componenttest // import "go.opentelemetry.io/collector/component/componenttest" 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/component" 8 | ) 9 | 10 | // nopHost mocks a receiver.ReceiverHost for test purposes. 11 | type nopHost struct{} 12 | 13 | // NewNopHost returns a new instance of nopHost with proper defaults for most tests. 14 | func NewNopHost() component.Host { 15 | return &nopHost{} 16 | } 17 | 18 | func (nh *nopHost) ReportFatalError(_ error) {} 19 | 20 | func (nh *nopHost) GetFactory(_ component.Kind, _ component.Type) component.Factory { 21 | return nil 22 | } 23 | 24 | func (nh *nopHost) GetExtensions() map[component.ID]component.Component { 25 | return nil 26 | } 27 | 28 | func (nh *nopHost) GetExporters() map[component.DataType]map[component.ID]component.Component { 29 | return nil 30 | } 31 | -------------------------------------------------------------------------------- /component/componenttest/nop_host_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package componenttest 5 | 6 | import ( 7 | "errors" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | "github.com/stretchr/testify/require" 12 | 13 | "go.opentelemetry.io/collector/component" 14 | ) 15 | 16 | func TestNewNopHost(t *testing.T) { 17 | nh := NewNopHost() 18 | require.NotNil(t, nh) 19 | require.IsType(t, &nopHost{}, nh) 20 | 21 | nh.ReportFatalError(errors.New("TestError")) 22 | assert.Nil(t, nh.GetExporters()) // nolint: staticcheck 23 | assert.Nil(t, nh.GetExtensions()) 24 | assert.Nil(t, nh.GetFactory(component.KindReceiver, "test")) 25 | } 26 | -------------------------------------------------------------------------------- /component/componenttest/nop_telemetry.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package componenttest // import "go.opentelemetry.io/collector/component/componenttest" 5 | 6 | import ( 7 | "go.opentelemetry.io/otel/metric/noop" 8 | "go.opentelemetry.io/otel/trace" 9 | "go.uber.org/zap" 10 | 11 | "go.opentelemetry.io/collector/component" 12 | "go.opentelemetry.io/collector/config/configtelemetry" 13 | "go.opentelemetry.io/collector/pdata/pcommon" 14 | ) 15 | 16 | // NewNopTelemetrySettings returns a new nop telemetry settings for Create* functions. 17 | func NewNopTelemetrySettings() component.TelemetrySettings { 18 | return component.TelemetrySettings{ 19 | Logger: zap.NewNop(), 20 | TracerProvider: trace.NewNoopTracerProvider(), 21 | MeterProvider: noop.NewMeterProvider(), 22 | MetricsLevel: configtelemetry.LevelNone, 23 | Resource: pcommon.NewResource(), 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /component/componenttest/nop_telemetry_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package componenttest 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | 11 | "go.opentelemetry.io/collector/config/configtelemetry" 12 | ) 13 | 14 | func TestNewNopTelemetrySettings(t *testing.T) { 15 | nts := NewNopTelemetrySettings() 16 | assert.NotNil(t, nts.Logger) 17 | assert.NotNil(t, nts.TracerProvider) 18 | assert.NotPanics(t, func() { 19 | nts.TracerProvider.Tracer("test") 20 | }) 21 | assert.NotNil(t, nts.MeterProvider) 22 | assert.NotPanics(t, func() { 23 | nts.MeterProvider.Meter("test") 24 | }) 25 | assert.Equal(t, configtelemetry.LevelNone, nts.MetricsLevel) 26 | assert.Equal(t, nts.Resource.Attributes().Len(), 0) 27 | } 28 | -------------------------------------------------------------------------------- /component/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package component outlines the components used in the collector 5 | // and provides a foundation for the component’s creation and 6 | // termination process. A component can be either a receiver, exporter, 7 | // processor, or an extension. 8 | package component // import "go.opentelemetry.io/collector/component" 9 | -------------------------------------------------------------------------------- /component/telemetry.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package component // import "go.opentelemetry.io/collector/component" 5 | 6 | import ( 7 | "go.opentelemetry.io/otel/metric" 8 | "go.opentelemetry.io/otel/trace" 9 | "go.uber.org/zap" 10 | 11 | "go.opentelemetry.io/collector/config/configtelemetry" 12 | "go.opentelemetry.io/collector/pdata/pcommon" 13 | ) 14 | 15 | type TelemetrySettings struct { 16 | // Logger that the factory can use during creation and can pass to the created 17 | // component to be used later as well. 18 | Logger *zap.Logger 19 | 20 | // TracerProvider that the factory can pass to other instrumented third-party libraries. 21 | TracerProvider trace.TracerProvider 22 | 23 | // MeterProvider that the factory can pass to other instrumented third-party libraries. 24 | MeterProvider metric.MeterProvider 25 | 26 | // MetricsLevel controls the level of detail for metrics emitted by the collector. 27 | // Experimental: *NOTE* this field is experimental and may be changed or removed. 28 | MetricsLevel configtelemetry.Level 29 | 30 | // Resource contains the resource attributes for the collector's telemetry. 31 | Resource pcommon.Resource 32 | } 33 | -------------------------------------------------------------------------------- /config/configauth/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/configcompression/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/configcompression/compressionType.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package configcompression // import "go.opentelemetry.io/collector/config/configcompression" 5 | 6 | import "fmt" 7 | 8 | type CompressionType string 9 | 10 | const ( 11 | Gzip CompressionType = "gzip" 12 | Zlib CompressionType = "zlib" 13 | Deflate CompressionType = "deflate" 14 | Snappy CompressionType = "snappy" 15 | Zstd CompressionType = "zstd" 16 | none CompressionType = "none" 17 | empty CompressionType = "" 18 | ) 19 | 20 | func IsCompressed(compressionType CompressionType) bool { 21 | return compressionType != empty && compressionType != none 22 | } 23 | 24 | func (ct *CompressionType) UnmarshalText(in []byte) error { 25 | switch typ := CompressionType(in); typ { 26 | case Gzip, 27 | Zlib, 28 | Deflate, 29 | Snappy, 30 | Zstd, 31 | none, 32 | empty: 33 | *ct = typ 34 | return nil 35 | default: 36 | return fmt.Errorf("unsupported compression type %q", typ) 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /config/configcompression/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/config/configcompression 2 | 3 | go 1.20 4 | 5 | require github.com/stretchr/testify v1.8.4 6 | 7 | require ( 8 | github.com/davecgh/go-spew v1.1.1 // indirect 9 | github.com/pmezard/go-difflib v1.0.0 // indirect 10 | gopkg.in/yaml.v3 v3.0.1 // indirect 11 | ) 12 | -------------------------------------------------------------------------------- /config/configcompression/go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 2 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 3 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 4 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 5 | github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= 6 | github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= 7 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 8 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 9 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 10 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 11 | -------------------------------------------------------------------------------- /config/configgrpc/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/configgrpc/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package configgrpc defines the configuration settings to create 5 | // a gRPC client and server. 6 | package configgrpc // import "go.opentelemetry.io/collector/config/configgrpc" 7 | -------------------------------------------------------------------------------- /config/configgrpc/gzip.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package configgrpc // import "go.opentelemetry.io/collector/config/configgrpc" 5 | 6 | import ( 7 | // Import the gzip package which auto-registers the gzip gRPC compressor. 8 | _ "google.golang.org/grpc/encoding/gzip" 9 | ) 10 | -------------------------------------------------------------------------------- /config/configgrpc/testdata/ca.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIDNjCCAh4CCQC0I5IQT7eziDANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJB 3 | VTESMBAGA1UECAwJQXVzdHJhbGlhMQ8wDQYDVQQHDAZTeWRuZXkxEjAQBgNVBAoM 4 | CU15T3JnTmFtZTEVMBMGA1UEAwwMTXlDb21tb25OYW1lMB4XDTIyMDgwMzA0MTky 5 | MVoXDTMyMDczMTA0MTkyMVowXTELMAkGA1UEBhMCQVUxEjAQBgNVBAgMCUF1c3Ry 6 | YWxpYTEPMA0GA1UEBwwGU3lkbmV5MRIwEAYDVQQKDAlNeU9yZ05hbWUxFTATBgNV 7 | BAMMDE15Q29tbW9uTmFtZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB 8 | AMhGP0dy3zvkdx9zI+/XVjPOWlER0OUp7Sgzidc3nLOk42+bH4ofIVNtOFVqlNKi 9 | O1bImu238VdBhd6R5IZZ1ZdIMcCeDgSJYu2X9wA3m4PKz8IdXo5ly2OHghhmCvqG 10 | WxgqDj5wPXiczQwuf1EcDMtRWbXJ6Z/XH1U68R/kRdNLkiZ2LwtjoQpis5XYckLL 11 | CrdF+AL6GeDIe0Mh9QGs26Vux+2kvaOGNUWRPE6Wt4GkqyKqmzYfR9HbflJ4xHT2 12 | I+jE1lg+jMBeom7z8Z90RE4GGcHjO+Vens/88r5EAjTnFj1Kb5gL2deSHY1m/++R 13 | Z/kRyg+zQJyw4fAzlAA4+VkCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAM3gRdTKX 14 | eGwGYVmmKqA2vTxeigQYLHml7OSopcWj2wJfxfp49HXPRuvgpQn9iubxO3Zmhd83 15 | 2X1E+T0A8oy5CfxgpAhHb3lY0jm3TjKXm6m+dSODwL3uND8tX+SqR8sRTFxPvPuo 16 | pmvhdTZoRI3EzIiHLTgCuSU25JNP/vrVoKk0JvCkDYTU/WcVfj0v95DTMoWR4JGz 17 | mtBwrgD0EM2XRw5ZMc7sMPli1gqmCbCQUrDZ+rPB78WDCBILBd8Cz75qYTUp98BY 18 | akJyBckdJHAdyEQYDKa9HpmpexOO7IhSXCTEN1DEBgpZgEi/lBDRG/b0OzenUUgt 19 | LUABtWt3pNQ9HA== 20 | -----END CERTIFICATE----- 21 | -------------------------------------------------------------------------------- /config/confighttp/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/confighttp/clientinfohandler_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package confighttp // import "go.opentelemetry.io/collector/config/confighttp" 5 | 6 | import ( 7 | "net" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | ) 12 | 13 | func TestParseIP(t *testing.T) { 14 | testCases := []struct { 15 | desc string 16 | input string 17 | expected *net.IPAddr 18 | }{ 19 | { 20 | desc: "addr", 21 | input: "1.2.3.4", 22 | expected: &net.IPAddr{ 23 | IP: net.IPv4(1, 2, 3, 4), 24 | }, 25 | }, 26 | { 27 | desc: "addr:port", 28 | input: "1.2.3.4:33455", 29 | expected: &net.IPAddr{ 30 | IP: net.IPv4(1, 2, 3, 4), 31 | }, 32 | }, 33 | { 34 | desc: "protocol://addr:port", 35 | input: "http://1.2.3.4:33455", 36 | expected: nil, 37 | }, 38 | { 39 | desc: "addr/path", 40 | input: "1.2.3.4/orders", 41 | expected: nil, 42 | }, 43 | } 44 | for _, tC := range testCases { 45 | t.Run(tC.desc, func(t *testing.T) { 46 | assert.Equal(t, tC.expected, parseIP(tC.input)) 47 | }) 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /config/confighttp/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package confighttp defines the configuration settings 5 | // for creating an HTTP client and server. 6 | package confighttp // import "go.opentelemetry.io/collector/config/confighttp" 7 | -------------------------------------------------------------------------------- /config/confignet/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/confignet/README.md: -------------------------------------------------------------------------------- 1 | # Network Configuration Settings 2 | 3 | [Receivers](https://github.com/open-telemetry/opentelemetry-collector/blob/main/receiver/README.md) 4 | leverage network configuration to set connection and transport information. 5 | 6 | - `endpoint`: Configures the address for this network connection. For TCP and 7 | UDP networks, the address has the form "host:port". The host must be a 8 | literal IP address, or a host name that can be resolved to IP addresses. The 9 | port must be a literal port number or a service name. If the host is a 10 | literal IPv6 address it must be enclosed in square brackets, as in 11 | "[2001:db8::1]:80" or "[fe80::1%zone]:80". The zone specifies the scope of 12 | the literal IPv6 address as defined in RFC 4007. 13 | - `transport`: Known protocols are "tcp", "tcp4" (IPv4-only), "tcp6" 14 | (IPv6-only), "udp", "udp4" (IPv4-only), "udp6" (IPv6-only), "ip", "ip4" 15 | (IPv4-only), "ip6" (IPv6-only), "unix", "unixgram" and "unixpacket". 16 | 17 | Note that for TCP receivers only the `endpoint` configuration setting is 18 | required. 19 | -------------------------------------------------------------------------------- /config/confignet/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package confignet implements the configuration settings for protocols to 5 | // connect and transport data information. 6 | package confignet // import "go.opentelemetry.io/collector/config/confignet" 7 | -------------------------------------------------------------------------------- /config/confignet/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/config/confignet 2 | 3 | go 1.20 4 | 5 | require github.com/stretchr/testify v1.8.4 6 | 7 | require ( 8 | github.com/davecgh/go-spew v1.1.1 // indirect 9 | github.com/pmezard/go-difflib v1.0.0 // indirect 10 | gopkg.in/yaml.v3 v3.0.1 // indirect 11 | ) 12 | -------------------------------------------------------------------------------- /config/confignet/go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 2 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 3 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 4 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 5 | github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= 6 | github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= 7 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 8 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 9 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 10 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 11 | -------------------------------------------------------------------------------- /config/configopaque/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/configopaque/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package configopaque implements String type alias to mask sensitive information. 5 | // Use configopaque.String on the type of sensitive fields, to mask the 6 | // opaque string as `[REDACTED]`. 7 | // 8 | // This ensure that no sensitive information is leaked when printing the 9 | // full Collector configurations. 10 | package configopaque // import "go.opentelemetry.io/collector/config/configopaque" 11 | -------------------------------------------------------------------------------- /config/configopaque/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/config/configopaque 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/stretchr/testify v1.8.4 7 | gopkg.in/yaml.v3 v3.0.1 8 | ) 9 | 10 | require ( 11 | github.com/davecgh/go-spew v1.1.1 // indirect 12 | github.com/pmezard/go-difflib v1.0.0 // indirect 13 | ) 14 | -------------------------------------------------------------------------------- /config/configopaque/go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 2 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 3 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 4 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 5 | github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= 6 | github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= 7 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 8 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 9 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 10 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 11 | -------------------------------------------------------------------------------- /config/configopaque/opaque.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package configopaque // import "go.opentelemetry.io/collector/config/configopaque" 5 | 6 | import ( 7 | "encoding" 8 | ) 9 | 10 | // String alias that is marshaled in an opaque way. 11 | type String string 12 | 13 | const maskedString = "[REDACTED]" 14 | 15 | var _ encoding.TextMarshaler = String("") 16 | 17 | // MarshalText marshals the string as `[REDACTED]`. 18 | func (s String) MarshalText() ([]byte, error) { 19 | return []byte(maskedString), nil 20 | } 21 | -------------------------------------------------------------------------------- /config/configopaque/opaque_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package configopaque // import "go.opentelemetry.io/collector/config/configopaque" 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | "github.com/stretchr/testify/require" 11 | ) 12 | 13 | func TestStringMarshalText(t *testing.T) { 14 | examples := []String{"opaque", "s", "veryveryveryveryveryveryveryveryveryverylong"} 15 | for _, example := range examples { 16 | opaque, err := example.MarshalText() 17 | require.NoError(t, err) 18 | assert.Equal(t, "[REDACTED]", string(opaque)) 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /config/configtelemetry/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/configtelemetry/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package configtelemetry defines various telemetry level for configuration. 5 | // It enables every component to have access to telemetry level 6 | // to enable metrics only when necessary. 7 | package configtelemetry // import "go.opentelemetry.io/collector/config/configtelemetry" 8 | -------------------------------------------------------------------------------- /config/configtelemetry/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/config/configtelemetry 2 | 3 | go 1.20 4 | 5 | require github.com/stretchr/testify v1.8.4 6 | 7 | require ( 8 | github.com/davecgh/go-spew v1.1.1 // indirect 9 | github.com/pmezard/go-difflib v1.0.0 // indirect 10 | gopkg.in/yaml.v3 v3.0.1 // indirect 11 | ) 12 | -------------------------------------------------------------------------------- /config/configtelemetry/go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 2 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 3 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 4 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 5 | github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= 6 | github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= 7 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 8 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 9 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 10 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 11 | -------------------------------------------------------------------------------- /config/configtls/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/configtls/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package configtls implements the TLS settings to load and 5 | // configure TLS clients and servers. 6 | package configtls // import "go.opentelemetry.io/collector/config/configtls" 7 | -------------------------------------------------------------------------------- /config/configtls/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/config/configtls 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/fsnotify/fsnotify v1.6.0 7 | github.com/stretchr/testify v1.8.4 8 | go.opentelemetry.io/collector/config/configopaque v0.83.0 9 | ) 10 | 11 | require ( 12 | github.com/davecgh/go-spew v1.1.1 // indirect 13 | github.com/pmezard/go-difflib v1.0.0 // indirect 14 | golang.org/x/sys v0.11.0 // indirect 15 | gopkg.in/yaml.v3 v3.0.1 // indirect 16 | ) 17 | 18 | replace go.opentelemetry.io/collector/config/configopaque => ../configopaque 19 | -------------------------------------------------------------------------------- /config/configtls/testdata/testCA-bad.txt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | bad certificate 3 | -----END CERTIFICATE----- 4 | -------------------------------------------------------------------------------- /config/internal/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /config/internal/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/config/internal 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/stretchr/testify v1.8.4 7 | go.uber.org/zap v1.25.0 8 | ) 9 | 10 | require ( 11 | github.com/davecgh/go-spew v1.1.1 // indirect 12 | github.com/pmezard/go-difflib v1.0.0 // indirect 13 | go.uber.org/multierr v1.10.0 // indirect 14 | gopkg.in/yaml.v3 v3.0.1 // indirect 15 | ) 16 | -------------------------------------------------------------------------------- /confmap/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /confmap/confmaptest/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package confmaptest helps loading confmap.Conf to test packages implementing using the configuration. 5 | package confmaptest // import "go.opentelemetry.io/collector/confmap/confmaptest" 6 | -------------------------------------------------------------------------------- /confmap/confmaptest/testdata/invalid.yaml: -------------------------------------------------------------------------------- 1 | [invalid, -------------------------------------------------------------------------------- /confmap/confmaptest/testdata/simple.yaml: -------------------------------------------------------------------------------- 1 | floating: 3.14 2 | -------------------------------------------------------------------------------- /confmap/converter.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package confmap // import "go.opentelemetry.io/collector/confmap" 5 | 6 | import ( 7 | "context" 8 | ) 9 | 10 | // Converter is a converter interface for the confmap.Conf that allows distributions 11 | // (in the future components as well) to build backwards compatible config converters. 12 | type Converter interface { 13 | // Convert applies the conversion logic to the given "conf". 14 | Convert(ctx context.Context, conf *Conf) error 15 | } 16 | -------------------------------------------------------------------------------- /confmap/converter/expandconverter/testdata/default-config.yaml: -------------------------------------------------------------------------------- 1 | processors: 2 | batch: 3 | exporters: 4 | otlp: 5 | endpoint: "localhost:4317" 6 | -------------------------------------------------------------------------------- /confmap/converter/expandconverter/testdata/expand-escaped-env.yaml: -------------------------------------------------------------------------------- 1 | test_map: 2 | # $$ -> escaped $ 3 | recv.1: "$$MAP_VALUE_1" 4 | # $$$ -> escaped $ + substituted env var 5 | recv.2: "$$$MAP_VALUE_2" 6 | # $$$$ -> two escaped $ 7 | recv.3: "$$$$MAP_VALUE_3" 8 | # escaped $ in the middle 9 | recv.4: "some$${MAP_VALUE_4}text" 10 | # two escaped $ 11 | recv.5: "$${ONE}$${TWO}" 12 | # trailing escaped $ 13 | recv.6: "text$$" 14 | # escaped $ alone 15 | recv.7: "$$" 16 | -------------------------------------------------------------------------------- /confmap/converter/expandconverter/testdata/expand-with-all-env.yaml: -------------------------------------------------------------------------------- 1 | test_map: 2 | extra: "$EXTRA" 3 | extra_map: 4 | recv.1: "$EXTRA_MAP_VALUE_1" 5 | recv.2: "${EXTRA_MAP_VALUE_2}" 6 | extra_list_map: 7 | - { recv.1: "$EXTRA_LIST_MAP_VALUE_1",recv.2: "${EXTRA_LIST_MAP_VALUE_2}" } 8 | extra_list: 9 | - "$EXTRA_LIST_VALUE_1" 10 | - "${EXTRA_LIST_VALUE_2}" 11 | 12 | -------------------------------------------------------------------------------- /confmap/converter/expandconverter/testdata/expand-with-no-env.yaml: -------------------------------------------------------------------------------- 1 | test_map: 2 | extra: "some string" 3 | extra_map: 4 | recv.1: "some map value_1" 5 | recv.2: "some map value_2" 6 | extra_list_map: 7 | - { recv.1: "some list map value_1",recv.2: "some list map value_2" } 8 | extra_list: 9 | - "some list value_1" 10 | - "some list value_2" 11 | -------------------------------------------------------------------------------- /confmap/converter/expandconverter/testdata/expand-with-partial-env.yaml: -------------------------------------------------------------------------------- 1 | test_map: 2 | extra: "${EXTRA}" 3 | extra_map: 4 | recv.1: "${EXTRA_MAP_VALUE_1}" 5 | recv.2: "some map value_2" 6 | extra_list_map: 7 | - { recv.1: "some list map value_1",recv.2: "${EXTRA_LIST_MAP_VALUE_2}" } 8 | extra_list: 9 | - "some list value_1" 10 | - "$EXTRA_LIST_VALUE_2" 11 | -------------------------------------------------------------------------------- /confmap/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/confmap 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/knadh/koanf/maps v0.1.1 7 | github.com/knadh/koanf/providers/confmap v0.1.0 8 | github.com/knadh/koanf/v2 v2.0.1 9 | github.com/mitchellh/mapstructure v1.5.0 10 | github.com/stretchr/testify v1.8.4 11 | go.opentelemetry.io/collector/featuregate v1.0.0-rcv0014 12 | go.uber.org/multierr v1.11.0 13 | gopkg.in/yaml.v3 v3.0.1 14 | ) 15 | 16 | require ( 17 | github.com/davecgh/go-spew v1.1.1 // indirect 18 | github.com/kr/text v0.2.0 // indirect 19 | github.com/mitchellh/copystructure v1.2.0 // indirect 20 | github.com/mitchellh/reflectwalk v1.0.2 // indirect 21 | github.com/pmezard/go-difflib v1.0.0 // indirect 22 | ) 23 | 24 | replace go.opentelemetry.io/collector/featuregate => ../featuregate 25 | 26 | retract ( 27 | v0.76.0 // Depends on retracted pdata v1.0.0-rc10 module, use v0.76.1 28 | v0.69.0 // Release failed, use v0.69.1 29 | ) 30 | -------------------------------------------------------------------------------- /confmap/provider/fileprovider/testdata/default-config.yaml: -------------------------------------------------------------------------------- 1 | processors: 2 | batch: 3 | exporters: 4 | otlp: 5 | endpoint: "localhost:4317" 6 | -------------------------------------------------------------------------------- /confmap/provider/fileprovider/testdata/invalid-yaml.yaml: -------------------------------------------------------------------------------- 1 | [invalid, -------------------------------------------------------------------------------- /confmap/provider/httpprovider/README.md: -------------------------------------------------------------------------------- 1 | What is this new component httpprovider? 2 | - An implementation of `confmap.Provider` for HTTP (httpprovider) allows OTEL Collector the ability to load configuration for itself by fetching and reading config files stored in HTTP servers. 3 | 4 | How this new component httpprovider works? 5 | - It will be called by `confmap.Resolver` to load configurations for OTEL Collector. 6 | - By giving a config URI starting with prefix 'http://', this httpprovider will be used to download config files from given HTTP URIs, and then used the downloaded config files to deploy the OTEL Collector. 7 | - In our code, we check the validity scheme and string pattern of HTTP URIs. And also check if there are any problems on config downloading and config deserialization. 8 | 9 | Expected URI format: 10 | - http://... 11 | 12 | Prerequistes: 13 | - Need to setup a HTTP server ahead, which returns with a config files according to the given URI -------------------------------------------------------------------------------- /confmap/provider/httpprovider/provider.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package httpprovider // import "go.opentelemetry.io/collector/confmap/provider/httpprovider" 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/confmap" 8 | "go.opentelemetry.io/collector/confmap/provider/internal/configurablehttpprovider" 9 | ) 10 | 11 | // New returns a new confmap.Provider that reads the configuration from a http server. 12 | // 13 | // This Provider supports "http" scheme. 14 | // 15 | // One example for HTTP URI is: http://localhost:3333/getConfig 16 | func New() confmap.Provider { 17 | return configurablehttpprovider.New(configurablehttpprovider.HTTPScheme) 18 | } 19 | -------------------------------------------------------------------------------- /confmap/provider/httpprovider/provider_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package httpprovider 5 | 6 | import ( 7 | "context" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | "github.com/stretchr/testify/require" 12 | ) 13 | 14 | func TestSupportedScheme(t *testing.T) { 15 | fp := New() 16 | assert.Equal(t, "http", fp.Scheme()) 17 | require.NoError(t, fp.Shutdown(context.Background())) 18 | } 19 | -------------------------------------------------------------------------------- /confmap/provider/httpsprovider/README.md: -------------------------------------------------------------------------------- 1 | ### What is the httpsprovider? 2 | 3 | An implementation of `confmap.Provider` for HTTPS (httpsprovider) allows OTEL Collector to use the HTTPS protocol to 4 | load configuration files stored in web servers. 5 | 6 | Expected URI format: 7 | - https://... 8 | 9 | ### Prerequistes 10 | 11 | You need to setup a HTTP server with support to HTTPS. The server must have a certificate that can be validated in the 12 | host running the collector using system root certificates. 13 | 14 | ### Configuration 15 | 16 | At this moment, this component only support communicating with servers whose certificate can be verified using the root 17 | CA certificates installed in the system. The process of adding more root CA certificates to the system is operating 18 | system dependent. For Linux, please refer to the `update-ca-trust` command. 19 | -------------------------------------------------------------------------------- /confmap/provider/httpsprovider/provider.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package httpsprovider // import "go.opentelemetry.io/collector/confmap/provider/httpsprovider" 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/confmap" 8 | "go.opentelemetry.io/collector/confmap/provider/internal/configurablehttpprovider" 9 | ) 10 | 11 | // New returns a new confmap.Provider that reads the configuration from a https server. 12 | // 13 | // This Provider supports "https" scheme. One example of an HTTPS URI is: https://localhost:3333/getConfig 14 | // 15 | // To add extra CA certificates you need to install certificates in the system pool. This procedure is operating system 16 | // dependent. E.g.: on Linux please refer to the `update-ca-trust` command. 17 | func New() confmap.Provider { 18 | return configurablehttpprovider.New(configurablehttpprovider.HTTPSScheme) 19 | } 20 | -------------------------------------------------------------------------------- /confmap/provider/httpsprovider/provider_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package httpsprovider 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestSupportedScheme(t *testing.T) { 13 | fp := New() 14 | assert.Equal(t, "https", fp.Scheme()) 15 | } 16 | -------------------------------------------------------------------------------- /confmap/provider/internal/configurablehttpprovider/testdata/otel-config.yaml: -------------------------------------------------------------------------------- 1 | extensions: 2 | memory_ballast: 3 | size_mib: 512 4 | zpages: 5 | endpoint: 0.0.0.0:55679 6 | 7 | receivers: 8 | otlp: 9 | protocols: 10 | grpc: 11 | http: 12 | 13 | processors: 14 | batch: 15 | memory_limiter: 16 | # 75% of maximum memory up to 4G 17 | limit_mib: 1536 18 | # 25% of limit up to 2G 19 | spike_limit_mib: 512 20 | check_interval: 5s 21 | 22 | exporters: 23 | logging: 24 | loglevel: debug 25 | 26 | service: 27 | pipelines: 28 | traces: 29 | receivers: [otlp] 30 | processors: [memory_limiter, batch] 31 | exporters: [logging] 32 | metrics: 33 | receivers: [otlp] 34 | processors: [memory_limiter, batch] 35 | exporters: [logging] 36 | 37 | extensions: [memory_ballast, zpages] 38 | -------------------------------------------------------------------------------- /confmap/provider/internal/provider.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/confmap/provider/internal" 5 | 6 | import ( 7 | "gopkg.in/yaml.v3" 8 | 9 | "go.opentelemetry.io/collector/confmap" 10 | ) 11 | 12 | // NewRetrievedFromYAML returns a new Retrieved instance that contains the deserialized data from the yaml bytes. 13 | // * yamlBytes the yaml bytes that will be deserialized. 14 | // * opts specifies options associated with this Retrieved value, such as CloseFunc. 15 | func NewRetrievedFromYAML(yamlBytes []byte, opts ...confmap.RetrievedOption) (*confmap.Retrieved, error) { 16 | var rawConf any 17 | if err := yaml.Unmarshal(yamlBytes, &rawConf); err != nil { 18 | return nil, err 19 | } 20 | return confmap.NewRetrieved(rawConf, opts...) 21 | } 22 | -------------------------------------------------------------------------------- /confmap/provider_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package confmap 5 | 6 | import ( 7 | "context" 8 | "errors" 9 | "testing" 10 | 11 | "github.com/stretchr/testify/assert" 12 | "github.com/stretchr/testify/require" 13 | ) 14 | 15 | func TestNewRetrieved(t *testing.T) { 16 | ret, err := NewRetrieved(nil) 17 | require.NoError(t, err) 18 | retMap, err := ret.AsConf() 19 | require.NoError(t, err) 20 | assert.Equal(t, New(), retMap) 21 | assert.NoError(t, ret.Close(context.Background())) 22 | } 23 | 24 | func TestNewRetrievedWithOptions(t *testing.T) { 25 | want := errors.New("my error") 26 | ret, err := NewRetrieved(nil, WithRetrievedClose(func(context.Context) error { return want })) 27 | require.NoError(t, err) 28 | retMap, err := ret.AsConf() 29 | require.NoError(t, err) 30 | assert.Equal(t, New(), retMap) 31 | assert.Equal(t, want, ret.Close(context.Background())) 32 | } 33 | 34 | func TestNewRetrievedUnsupportedType(t *testing.T) { 35 | _, err := NewRetrieved(errors.New("my error")) 36 | require.Error(t, err) 37 | } 38 | -------------------------------------------------------------------------------- /confmap/testdata/basic_types.yaml: -------------------------------------------------------------------------------- 1 | typed.options: 2 | floating.point.example: 3.14 3 | integer.example: 1234 4 | bool.example: false 5 | string.example: this is a string 6 | nil.example: 7 | -------------------------------------------------------------------------------- /confmap/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | nop/myreceiver: 4 | 5 | processors: 6 | nop: 7 | nop/myprocessor: 8 | 9 | exporters: 10 | nop: 11 | nop/myexporter: 12 | 13 | extensions: 14 | nop: 15 | nop/myextension: 16 | 17 | service: 18 | extensions: [nop] 19 | pipelines: 20 | traces: 21 | receivers: [nop] 22 | processors: [nop] 23 | exporters: [nop] 24 | -------------------------------------------------------------------------------- /confmap/testdata/embedded_keys.yaml: -------------------------------------------------------------------------------- 1 | typed::options: 2 | floating::point::example: 3.14 3 | integer::example: 1234 4 | bool::example: false 5 | string::example: this is a string 6 | nil::example: 7 | -------------------------------------------------------------------------------- /confmap/testdata/expand-with-all-env.yaml: -------------------------------------------------------------------------------- 1 | test_map: 2 | extra: "${env:EXTRA}" 3 | extra_map: 4 | recv.1: "${env:EXTRA_MAP_VALUE_1}" 5 | recv.2: "${env:EXTRA_MAP_VALUE_2}" 6 | extra_list_map: 7 | - { recv.1: "${env:EXTRA_LIST_MAP_VALUE_1}",recv.2: "${env:EXTRA_LIST_MAP_VALUE_2}" } 8 | extra_list: 9 | - "${env:EXTRA_LIST_VALUE_1}" 10 | - "${env:EXTRA_LIST_VALUE_2}" 11 | 12 | -------------------------------------------------------------------------------- /confmap/testdata/expand-with-no-env.yaml: -------------------------------------------------------------------------------- 1 | test_map: 2 | extra: "some string" 3 | extra_map: 4 | recv.1: "some map value_1" 5 | recv.2: "some map value_2" 6 | extra_list_map: 7 | - { recv.1: "some list map value_1",recv.2: "some list map value_2" } 8 | extra_list: 9 | - "some list value_1" 10 | - "some list value_2" 11 | -------------------------------------------------------------------------------- /confmap/testdata/expand-with-partial-env.yaml: -------------------------------------------------------------------------------- 1 | test_map: 2 | extra: "${env:EXTRA}" 3 | extra_map: 4 | recv.1: "${env:EXTRA_MAP_VALUE_1}" 5 | recv.2: "some map value_2" 6 | extra_list_map: 7 | - { recv.1: "some list map value_1",recv.2: "${env:EXTRA_LIST_MAP_VALUE_2}" } 8 | extra_list: 9 | - "some list value_1" 10 | - "${env:EXTRA_LIST_VALUE_2}" 11 | -------------------------------------------------------------------------------- /connector/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /connector/forwardconnector/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /connector/forwardconnector/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package forwardconnector passes signals from one pipeline to another. 5 | package forwardconnector // import "go.opentelemetry.io/collector/connector/forwardconnector" 6 | -------------------------------------------------------------------------------- /consumer/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /consumer/consumererror/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package consumererror provides wrappers to easily classify errors. This allows 5 | // appropriate action by error handlers without the need to know each individual 6 | // error type/instance. 7 | package consumererror // import "go.opentelemetry.io/collector/consumer/consumererror" 8 | -------------------------------------------------------------------------------- /consumer/consumererror/permanent.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package consumererror // import "go.opentelemetry.io/collector/consumer/consumererror" 5 | 6 | import "errors" 7 | 8 | // permanent is an error that will be always returned if its source 9 | // receives the same inputs. 10 | type permanent struct { 11 | err error 12 | } 13 | 14 | // NewPermanent wraps an error to indicate that it is a permanent error, i.e. an 15 | // error that will be always returned if its source receives the same inputs. 16 | func NewPermanent(err error) error { 17 | return permanent{err: err} 18 | } 19 | 20 | func (p permanent) Error() string { 21 | return "Permanent error: " + p.err.Error() 22 | } 23 | 24 | // Unwrap returns the wrapped error for functions Is and As in standard package errors. 25 | func (p permanent) Unwrap() error { 26 | return p.err 27 | } 28 | 29 | // IsPermanent checks if an error was wrapped with the NewPermanent function, which 30 | // is used to indicate that a given error will always be returned in the case 31 | // that its sources receives the same input. 32 | func IsPermanent(err error) bool { 33 | if err == nil { 34 | return false 35 | } 36 | return errors.As(err, &permanent{}) 37 | } 38 | -------------------------------------------------------------------------------- /consumer/consumertest/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package consumertest defines types and functions used to help test packages 5 | // implementing the consumer package interfaces. 6 | package consumertest // import "go.opentelemetry.io/collector/consumer/consumertest" 7 | -------------------------------------------------------------------------------- /consumer/consumertest/err.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package consumertest // import "go.opentelemetry.io/collector/consumer/consumertest" 5 | import ( 6 | "context" 7 | 8 | "go.opentelemetry.io/collector/pdata/plog" 9 | "go.opentelemetry.io/collector/pdata/pmetric" 10 | "go.opentelemetry.io/collector/pdata/ptrace" 11 | ) 12 | 13 | // NewErr returns a Consumer that just drops all received data and returns the specified error to Consume* callers. 14 | func NewErr(err error) Consumer { 15 | return &baseConsumer{ 16 | ConsumeTracesFunc: func(ctx context.Context, td ptrace.Traces) error { return err }, 17 | ConsumeMetricsFunc: func(ctx context.Context, md pmetric.Metrics) error { return err }, 18 | ConsumeLogsFunc: func(ctx context.Context, ld plog.Logs) error { return err }, 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /consumer/consumertest/err_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package consumertest 5 | 6 | import ( 7 | "context" 8 | "errors" 9 | "testing" 10 | 11 | "github.com/stretchr/testify/assert" 12 | "github.com/stretchr/testify/require" 13 | 14 | "go.opentelemetry.io/collector/pdata/plog" 15 | "go.opentelemetry.io/collector/pdata/pmetric" 16 | "go.opentelemetry.io/collector/pdata/ptrace" 17 | ) 18 | 19 | func TestErr(t *testing.T) { 20 | err := errors.New("my error") 21 | ec := NewErr(err) 22 | require.NotNil(t, ec) 23 | assert.NotPanics(t, ec.unexported) 24 | assert.Equal(t, err, ec.ConsumeLogs(context.Background(), plog.NewLogs())) 25 | assert.Equal(t, err, ec.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) 26 | assert.Equal(t, err, ec.ConsumeTraces(context.Background(), ptrace.NewTraces())) 27 | } 28 | -------------------------------------------------------------------------------- /consumer/consumertest/nop.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package consumertest // import "go.opentelemetry.io/collector/consumer/consumertest" 5 | 6 | import ( 7 | "context" 8 | 9 | "go.opentelemetry.io/collector/pdata/plog" 10 | "go.opentelemetry.io/collector/pdata/pmetric" 11 | "go.opentelemetry.io/collector/pdata/ptrace" 12 | ) 13 | 14 | // NewNop returns a Consumer that just drops all received data and returns no error. 15 | func NewNop() Consumer { 16 | return &baseConsumer{ 17 | ConsumeTracesFunc: func(ctx context.Context, td ptrace.Traces) error { return nil }, 18 | ConsumeMetricsFunc: func(ctx context.Context, md pmetric.Metrics) error { return nil }, 19 | ConsumeLogsFunc: func(ctx context.Context, ld plog.Logs) error { return nil }, 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /consumer/consumertest/nop_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package consumertest 5 | 6 | import ( 7 | "context" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | "github.com/stretchr/testify/require" 12 | 13 | "go.opentelemetry.io/collector/pdata/plog" 14 | "go.opentelemetry.io/collector/pdata/pmetric" 15 | "go.opentelemetry.io/collector/pdata/ptrace" 16 | ) 17 | 18 | func TestNop(t *testing.T) { 19 | nc := NewNop() 20 | require.NotNil(t, nc) 21 | assert.NotPanics(t, nc.unexported) 22 | assert.NoError(t, nc.ConsumeLogs(context.Background(), plog.NewLogs())) 23 | assert.NoError(t, nc.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) 24 | assert.NoError(t, nc.ConsumeTraces(context.Background(), ptrace.NewTraces())) 25 | } 26 | -------------------------------------------------------------------------------- /consumer/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package consumer contains interfaces that receive and process consumerdata. 5 | package consumer // import "go.opentelemetry.io/collector/consumer" 6 | -------------------------------------------------------------------------------- /docs/images/design-collector-agent.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/design-collector-agent.png -------------------------------------------------------------------------------- /docs/images/design-collector-service.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/design-collector-service.png -------------------------------------------------------------------------------- /docs/images/design-exporters.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/design-exporters.png -------------------------------------------------------------------------------- /docs/images/design-pipelines.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/design-pipelines.png -------------------------------------------------------------------------------- /docs/images/design-processors.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/design-processors.png -------------------------------------------------------------------------------- /docs/images/design-receivers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/design-receivers.png -------------------------------------------------------------------------------- /docs/images/design-service-lifecycle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/design-service-lifecycle.png -------------------------------------------------------------------------------- /docs/images/opentelemetry-service-deployment-models.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/opentelemetry-service-deployment-models.png -------------------------------------------------------------------------------- /docs/images/zpages-example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/docs/images/zpages-example.png -------------------------------------------------------------------------------- /examples/README.md: -------------------------------------------------------------------------------- 1 | # Examples 2 | 3 | Information on how the examples can be used can be found in the [Getting 4 | Started 5 | documentation](https://opentelemetry.io/docs/collector/getting-started/). 6 | -------------------------------------------------------------------------------- /examples/local/otel-config.yaml: -------------------------------------------------------------------------------- 1 | extensions: 2 | memory_ballast: 3 | size_mib: 512 4 | zpages: 5 | endpoint: localhost:55679 6 | 7 | receivers: 8 | otlp: 9 | protocols: 10 | grpc: 11 | endpoint: localhost:4317 12 | http: 13 | endpoint: localhost:4318 14 | 15 | processors: 16 | batch: 17 | memory_limiter: 18 | # 75% of maximum memory up to 4G 19 | limit_mib: 1536 20 | # 25% of limit up to 2G 21 | spike_limit_mib: 512 22 | check_interval: 5s 23 | 24 | exporters: 25 | logging: 26 | verbosity: detailed 27 | 28 | service: 29 | pipelines: 30 | traces: 31 | receivers: [otlp] 32 | processors: [memory_limiter, batch] 33 | exporters: [logging] 34 | metrics: 35 | receivers: [otlp] 36 | processors: [memory_limiter, batch] 37 | exporters: [logging] 38 | 39 | extensions: [memory_ballast, zpages] 40 | -------------------------------------------------------------------------------- /exporter/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /exporter/exporterhelper/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package exporterhelper // import "go.opentelemetry.io/collector/exporter/exporterhelper" 5 | 6 | import ( 7 | "errors" 8 | ) 9 | 10 | var ( 11 | // errNilConfig is returned when an empty name is given. 12 | errNilConfig = errors.New("nil config") 13 | // errNilLogger is returned when a logger is nil 14 | errNilLogger = errors.New("nil logger") 15 | // errNilPushTraceData is returned when a nil PushTraces is given. 16 | errNilPushTraceData = errors.New("nil PushTraces") 17 | // errNilPushMetricsData is returned when a nil PushMetrics is given. 18 | errNilPushMetricsData = errors.New("nil PushMetrics") 19 | // errNilPushLogsData is returned when a nil PushLogs is given. 20 | errNilPushLogsData = errors.New("nil PushLogs") 21 | ) 22 | -------------------------------------------------------------------------------- /exporter/exporterhelper/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package exporterhelper provides helper functions for exporters. 5 | package exporterhelper // import "go.opentelemetry.io/collector/exporter/exporterhelper" 6 | -------------------------------------------------------------------------------- /exporter/exporterhelper/internal/producer_consumer_queue.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // Copyright (c) 2019 The Jaeger Authors. 3 | // Copyright (c) 2017 Uber Technologies, Inc. 4 | // SPDX-License-Identifier: Apache-2.0 5 | 6 | package internal // import "go.opentelemetry.io/collector/exporter/exporterhelper/internal" 7 | 8 | // ProducerConsumerQueue defines a producer-consumer exchange which can be backed by e.g. the memory-based ring buffer queue 9 | // (boundedMemoryQueue) or via a disk-based queue (persistentQueue) 10 | type ProducerConsumerQueue interface { 11 | // StartConsumers starts a given number of goroutines consuming items from the queue 12 | // and passing them into the consumer callback. 13 | StartConsumers(num int, callback func(item Request)) 14 | // Produce is used by the producer to submit new item to the queue. Returns false if the item wasn't added 15 | // to the queue due to queue overflow. 16 | Produce(item Request) bool 17 | // Size returns the current Size of the queue 18 | Size() int 19 | // Stop stops all consumers, as well as the length reporter if started, 20 | // and releases the items channel. It blocks until all consumers have stopped. 21 | Stop() 22 | } 23 | -------------------------------------------------------------------------------- /exporter/loggingexporter/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /exporter/loggingexporter/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package loggingexporter exports data to console as logs. 5 | package loggingexporter // import "go.opentelemetry.io/collector/exporter/loggingexporter" 6 | -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/databuffer_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlptext 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | 11 | "go.opentelemetry.io/collector/pdata/pcommon" 12 | ) 13 | 14 | func TestNestedArraySerializesCorrectly(t *testing.T) { 15 | ava := pcommon.NewValueSlice() 16 | ava.Slice().AppendEmpty().SetStr("foo") 17 | ava.Slice().AppendEmpty().SetInt(42) 18 | ava.Slice().AppendEmpty().SetEmptySlice().AppendEmpty().SetStr("bar") 19 | ava.Slice().AppendEmpty().SetBool(true) 20 | ava.Slice().AppendEmpty().SetDouble(5.5) 21 | 22 | assert.Equal(t, `Slice(["foo",42,["bar"],true,5.5])`, valueToString(ava)) 23 | } 24 | 25 | func TestNestedMapSerializesCorrectly(t *testing.T) { 26 | ava := pcommon.NewValueMap() 27 | av := ava.Map() 28 | av.PutStr("foo", "test") 29 | av.PutEmptyMap("zoo").PutInt("bar", 13) 30 | 31 | assert.Equal(t, `Map({"foo":"test","zoo":{"bar":13}})`, valueToString(ava)) 32 | } 33 | -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/testdata/logs/embedded_maps.out: -------------------------------------------------------------------------------- 1 | ResourceLog #0 2 | Resource SchemaURL: 3 | ScopeLogs #0 4 | ScopeLogs SchemaURL: 5 | InstrumentationScope 6 | LogRecord #0 7 | ObservedTimestamp: 1970-01-01 00:00:00 +0000 UTC 8 | Timestamp: 2020-02-11 20:26:13.000000789 +0000 UTC 9 | SeverityText: INFO 10 | SeverityNumber: Info(9) 11 | Body: Map({"key1":"val1","key2":{"key21":"val21","key22":"val22"}}) 12 | Attributes: 13 | -> key1: Map({"key11":"val11","key12":"val12","key13":{"key131":"val131"}}) 14 | -> key2: Str(val2) 15 | Trace ID: 16 | Span ID: 17 | Flags: 0 18 | -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/testdata/logs/empty.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/exporter/loggingexporter/internal/otlptext/testdata/logs/empty.out -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/testdata/logs/one_record.out: -------------------------------------------------------------------------------- 1 | ResourceLog #0 2 | Resource SchemaURL: 3 | Resource attributes: 4 | -> resource-attr: Str(resource-attr-val-1) 5 | ScopeLogs #0 6 | ScopeLogs SchemaURL: 7 | InstrumentationScope 8 | LogRecord #0 9 | ObservedTimestamp: 1970-01-01 00:00:00 +0000 UTC 10 | Timestamp: 2020-02-11 20:26:13.000000789 +0000 UTC 11 | SeverityText: Info 12 | SeverityNumber: Info(9) 13 | Body: Str(This is a log message) 14 | Attributes: 15 | -> app: Str(server) 16 | -> instance_num: Int(1) 17 | Trace ID: 08040201000000000000000000000000 18 | Span ID: 0102040800000000 19 | Flags: 0 20 | -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/testdata/logs/two_records.out: -------------------------------------------------------------------------------- 1 | ResourceLog #0 2 | Resource SchemaURL: 3 | Resource attributes: 4 | -> resource-attr: Str(resource-attr-val-1) 5 | ScopeLogs #0 6 | ScopeLogs SchemaURL: 7 | InstrumentationScope 8 | LogRecord #0 9 | ObservedTimestamp: 1970-01-01 00:00:00 +0000 UTC 10 | Timestamp: 2020-02-11 20:26:13.000000789 +0000 UTC 11 | SeverityText: Info 12 | SeverityNumber: Info(9) 13 | Body: Str(This is a log message) 14 | Attributes: 15 | -> app: Str(server) 16 | -> instance_num: Int(1) 17 | Trace ID: 08040201000000000000000000000000 18 | Span ID: 0102040800000000 19 | Flags: 0 20 | LogRecord #1 21 | ObservedTimestamp: 1970-01-01 00:00:00 +0000 UTC 22 | Timestamp: 2020-02-11 20:26:13.000000789 +0000 UTC 23 | SeverityText: Info 24 | SeverityNumber: Info(9) 25 | Body: Str(something happened) 26 | Attributes: 27 | -> customer: Str(acme) 28 | -> env: Str(dev) 29 | Trace ID: 30 | Span ID: 31 | Flags: 0 32 | -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/testdata/metrics/empty.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/exporter/loggingexporter/internal/otlptext/testdata/metrics/empty.out -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/testdata/metrics/invalid_metric_type.out: -------------------------------------------------------------------------------- 1 | ResourceMetrics #0 2 | Resource SchemaURL: 3 | Resource attributes: 4 | -> resource-attr: Str(resource-attr-val-1) 5 | ScopeMetrics #0 6 | ScopeMetrics SchemaURL: 7 | InstrumentationScope 8 | Metric #0 9 | Descriptor: 10 | -> Name: sum-int 11 | -> Description: 12 | -> Unit: 1 13 | -> DataType: Empty 14 | -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/testdata/traces/empty.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/exporter/loggingexporter/internal/otlptext/testdata/traces/empty.out -------------------------------------------------------------------------------- /exporter/loggingexporter/internal/otlptext/traces_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlptext 5 | 6 | import ( 7 | "os" 8 | "path/filepath" 9 | "strings" 10 | "testing" 11 | 12 | "github.com/stretchr/testify/assert" 13 | "github.com/stretchr/testify/require" 14 | 15 | "go.opentelemetry.io/collector/internal/testdata" 16 | "go.opentelemetry.io/collector/pdata/ptrace" 17 | ) 18 | 19 | func TestTracesText(t *testing.T) { 20 | 21 | tests := []struct { 22 | name string 23 | in ptrace.Traces 24 | out string 25 | }{ 26 | { 27 | name: "empty_traces", 28 | in: ptrace.NewTraces(), 29 | out: "empty.out", 30 | }, 31 | { 32 | name: "two_spans", 33 | in: testdata.GenerateTraces(2), 34 | out: "two_spans.out", 35 | }, 36 | } 37 | for _, tt := range tests { 38 | t.Run(tt.name, func(t *testing.T) { 39 | got, err := NewTextTracesMarshaler().MarshalTraces(tt.in) 40 | assert.NoError(t, err) 41 | out, err := os.ReadFile(filepath.Join("testdata", "traces", tt.out)) 42 | require.NoError(t, err) 43 | expected := strings.ReplaceAll(string(out), "\r", "") 44 | assert.Equal(t, expected, string(got)) 45 | }) 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /exporter/loggingexporter/known_sync_error.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | //go:build linux || darwin 5 | // +build linux darwin 6 | 7 | package loggingexporter // import "go.opentelemetry.io/collector/exporter/loggingexporter" 8 | 9 | import ( 10 | "errors" 11 | "syscall" 12 | ) 13 | 14 | var knownSyncErrors = []error{ 15 | // sync /dev/stdout: invalid argument 16 | syscall.EINVAL, 17 | // sync /dev/stdout: not supported 18 | syscall.ENOTSUP, 19 | // sync /dev/stdout: inappropriate ioctl for device 20 | syscall.ENOTTY, 21 | // sync /dev/stdout: bad file descriptor 22 | syscall.EBADF, 23 | } 24 | 25 | // knownSyncError returns true if the given error is one of the known 26 | // non-actionable errors returned by Sync on Linux and macOS. 27 | func knownSyncError(err error) bool { 28 | for _, syncError := range knownSyncErrors { 29 | if errors.Is(err, syncError) { 30 | return true 31 | } 32 | } 33 | 34 | return false 35 | } 36 | -------------------------------------------------------------------------------- /exporter/loggingexporter/known_sync_error_other.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | //go:build !linux && !darwin && !windows 5 | // +build !linux,!darwin,!windows 6 | 7 | package loggingexporter // import "go.opentelemetry.io/collector/exporter/loggingexporter" 8 | 9 | // knownSyncError returns true if the given error is one of the known 10 | // non-actionable errors returned by Sync on Plan 9. 11 | func knownSyncError(err error) bool { 12 | return false 13 | } 14 | -------------------------------------------------------------------------------- /exporter/loggingexporter/known_sync_error_windows.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | //go:build windows 5 | // +build windows 6 | 7 | package loggingexporter // import "go.opentelemetry.io/collector/exporter/loggingexporter" 8 | 9 | import "golang.org/x/sys/windows" 10 | 11 | // knownSyncError returns true if the given error is one of the known 12 | // non-actionable errors returned by Sync on Windows: 13 | // 14 | // - sync /dev/stderr: The handle is invalid. 15 | func knownSyncError(err error) bool { 16 | return err == windows.ERROR_INVALID_HANDLE 17 | } 18 | -------------------------------------------------------------------------------- /exporter/loggingexporter/testdata/config_loglevel.yaml: -------------------------------------------------------------------------------- 1 | loglevel: debug 2 | sampling_initial: 10 3 | sampling_thereafter: 50 4 | -------------------------------------------------------------------------------- /exporter/loggingexporter/testdata/config_loglevel_typo.yaml: -------------------------------------------------------------------------------- 1 | # Typo in the configuration that assumes that this property is camelcase 2 | logLevel: debug 3 | -------------------------------------------------------------------------------- /exporter/loggingexporter/testdata/config_verbosity.yaml: -------------------------------------------------------------------------------- 1 | verbosity: detailed 2 | sampling_initial: 10 3 | sampling_thereafter: 50 4 | -------------------------------------------------------------------------------- /exporter/loggingexporter/testdata/invalid_verbosity_loglevel.yaml: -------------------------------------------------------------------------------- 1 | loglevel: info 2 | verbosity: detailed 3 | -------------------------------------------------------------------------------- /exporter/loggingexporter/testdata/loglevel_info.yaml: -------------------------------------------------------------------------------- 1 | loglevel: info 2 | -------------------------------------------------------------------------------- /exporter/otlpexporter/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /exporter/otlpexporter/arrow-design.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/exporter/otlpexporter/arrow-design.png -------------------------------------------------------------------------------- /exporter/otlpexporter/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package otlpexporter exports data by using the OTLP format to a gPRC endpoint. 5 | package otlpexporter // import "go.opentelemetry.io/collector/exporter/otlpexporter" 6 | -------------------------------------------------------------------------------- /exporter/otlpexporter/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | endpoint: "1.2.3.4:1234" 2 | compression: "gzip" 3 | tls: 4 | ca_file: /var/lib/mycert.pem 5 | timeout: 10s 6 | sending_queue: 7 | enabled: true 8 | num_consumers: 2 9 | queue_size: 10 10 | retry_on_failure: 11 | enabled: true 12 | initial_interval: 10s 13 | randomization_factor: 0.7 14 | multiplier: 1.3 15 | max_interval: 60s 16 | max_elapsed_time: 10m 17 | auth: 18 | authenticator: nop 19 | headers: 20 | "can you have a . here?": "F0000000-0000-0000-0000-000000000000" 21 | header1: 234 22 | another: "somevalue" 23 | keepalive: 24 | time: 20s 25 | timeout: 30s 26 | permit_without_stream: true 27 | balancer_name: "round_robin" 28 | arrow: 29 | num_streams: 2 30 | disabled: false 31 | enable_mixed_signals: true 32 | max_stream_lifetime: 2h 33 | -------------------------------------------------------------------------------- /exporter/otlpexporter/testdata/test_cert.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIICpDCCAYwCCQC5oaFsqLW3GTANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDDAls 3 | b2NhbGhvc3QwHhcNMjEwNzE0MDAxMzU2WhcNMzEwNzEyMDAxMzU2WjAUMRIwEAYD 4 | VQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDO 5 | mKaE1qg5VLMwaUnSzufT23rRJFbuy/HDXwsH63yZVSsISQkGjkBYBgrqAMtVnsI/ 6 | l4gXtBWkZtJFs68Sbo9ps3W0PdB5+d12R5NUNA1rkZtx3jtEN33dpGhifug/TIZe 7 | 7Zr0G1z6gNoaEezk0Jpg4KsH7QpIeHPRhIZMyWeqddgD/qL4/ukaU4NOORuF3WoT 8 | oo2LpI3jUq66mz2N2Inq0V/OX7BYB4Ur6EtjWh2baiUuw9fq+oLUlgZd6ypnugC/ 9 | +YfgYqvWtRntmEr0Z+O4Kz81P2IpH/0h1RFhWyK6thVGa9cx6aseCp3V2cMXfGfc 10 | z4n3Uvz87v+bZvGbcse/AgMBAAEwDQYJKoZIhvcNAQELBQADggEBAAlvNBNoqXUQ 11 | ohR0eozIHGeJ94U7WK5zXf2NSvmRlwHzHXvUq6GKd+8Bv1foMjI6OpSOZmjtRGsc 12 | rWET1WjSyQddRfqYazhWp1IyYu5LfATwPS+RXJAkWixKVfG+Ta2x6u+aT/bSZwEg 13 | NwRerc6pyqv5UG8Z7Pe1kAxbgOwZv5KXAewIgTSbEkmIp1Dg8GhGeWD5pjYNCkJV 14 | Na2KMAUWP3PeQzdSBKmBNpsRUALuSTxb5u7pl+PA7FLInTtDeyZn8xpO1GPBhbJE 15 | trDbmTbj5YexOXEaQtGtZ6fwRw2jnUm8nqtXozxIomnVTBO8vLmZAUgyJ71trRw0 16 | gE9tH5Ndlug= 17 | -----END CERTIFICATE----- 18 | -------------------------------------------------------------------------------- /exporter/otlphttpexporter/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /exporter/otlphttpexporter/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package otlphttpexporter exports data by using the OTLP format to an HTTP endpoint. 5 | package otlphttpexporter // import "go.opentelemetry.io/collector/exporter/otlphttpexporter" 6 | -------------------------------------------------------------------------------- /exporter/otlphttpexporter/testdata/bad_empty_config.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | 4 | processors: 5 | nop: 6 | 7 | exporters: 8 | otlphttp: 9 | 10 | service: 11 | pipelines: 12 | traces: 13 | receivers: [nop] 14 | processors: [nop] 15 | exporters: [otlphttp] 16 | -------------------------------------------------------------------------------- /exporter/otlphttpexporter/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | endpoint: "https://1.2.3.4:1234" 2 | tls: 3 | ca_file: /var/lib/mycert.pem 4 | cert_file: certfile 5 | key_file: keyfile 6 | insecure: true 7 | timeout: 10s 8 | read_buffer_size: 123 9 | write_buffer_size: 345 10 | sending_queue: 11 | enabled: true 12 | num_consumers: 2 13 | queue_size: 10 14 | retry_on_failure: 15 | enabled: true 16 | initial_interval: 10s 17 | randomization_factor: 0.7 18 | multiplier: 1.3 19 | max_interval: 60s 20 | max_elapsed_time: 10m 21 | headers: 22 | "can you have a . here?": "F0000000-0000-0000-0000-000000000000" 23 | header1: 234 24 | another: "somevalue" 25 | compression: gzip 26 | -------------------------------------------------------------------------------- /extension/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /extension/auth/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /extension/auth/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package auth implements the configuration settings to 5 | // ensure authentication on incoming requests, and allows 6 | // exporters to add authentication on outgoing requests. 7 | package auth // import "go.opentelemetry.io/collector/extension/auth" 8 | -------------------------------------------------------------------------------- /extension/ballastextension/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /extension/ballastextension/config.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ballastextension // import "go.opentelemetry.io/collector/extension/ballastextension" 5 | 6 | import ( 7 | "errors" 8 | ) 9 | 10 | // Config has the configuration for the ballast extension. 11 | type Config struct { 12 | // SizeMiB is the size, in MiB, of the memory ballast 13 | // to be created for this process. 14 | SizeMiB uint64 `mapstructure:"size_mib"` 15 | 16 | // SizeInPercentage is the maximum amount of memory ballast, in %, targeted to be 17 | // allocated. The fixed memory settings SizeMiB has a higher precedence. 18 | SizeInPercentage uint64 `mapstructure:"size_in_percentage"` 19 | } 20 | 21 | // Validate checks if the extension configuration is valid 22 | func (cfg *Config) Validate() error { 23 | // no need to validate less than 0 case for uint64 24 | if cfg.SizeInPercentage > 100 { 25 | return errors.New("size_in_percentage is not in range 0 to 100") 26 | } 27 | return nil 28 | } 29 | -------------------------------------------------------------------------------- /extension/ballastextension/factory.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ballastextension // import "go.opentelemetry.io/collector/extension/ballastextension" 5 | 6 | import ( 7 | "context" 8 | 9 | "go.opentelemetry.io/collector/component" 10 | "go.opentelemetry.io/collector/extension" 11 | "go.opentelemetry.io/collector/internal/iruntime" 12 | ) 13 | 14 | const ( 15 | // The value of extension "type" in configuration. 16 | typeStr = "memory_ballast" 17 | ) 18 | 19 | // memHandler returns the total memory of the target host/vm 20 | var memHandler = iruntime.TotalMemory 21 | 22 | // NewFactory creates a factory for FluentBit extension. 23 | func NewFactory() extension.Factory { 24 | return extension.NewFactory(typeStr, createDefaultConfig, createExtension, component.StabilityLevelBeta) 25 | } 26 | 27 | func createDefaultConfig() component.Config { 28 | return &Config{} 29 | } 30 | 31 | func createExtension(_ context.Context, set extension.CreateSettings, cfg component.Config) (extension.Extension, error) { 32 | return newMemoryBallast(cfg.(*Config), set.TelemetrySettings.Logger, memHandler), nil 33 | } 34 | -------------------------------------------------------------------------------- /extension/ballastextension/factory_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ballastextension 5 | 6 | import ( 7 | "context" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | "github.com/stretchr/testify/require" 12 | 13 | "go.opentelemetry.io/collector/component/componenttest" 14 | "go.opentelemetry.io/collector/extension/extensiontest" 15 | ) 16 | 17 | func TestFactory_CreateDefaultConfig(t *testing.T) { 18 | cfg := createDefaultConfig() 19 | assert.Equal(t, &Config{}, cfg) 20 | 21 | assert.NoError(t, componenttest.CheckConfigStruct(cfg)) 22 | ext, err := createExtension(context.Background(), extensiontest.NewNopCreateSettings(), cfg) 23 | require.NoError(t, err) 24 | require.NotNil(t, ext) 25 | } 26 | 27 | func TestFactory_CreateExtension(t *testing.T) { 28 | cfg := createDefaultConfig().(*Config) 29 | ext, err := createExtension(context.Background(), extensiontest.NewNopCreateSettings(), cfg) 30 | require.NoError(t, err) 31 | require.NotNil(t, ext) 32 | } 33 | -------------------------------------------------------------------------------- /extension/ballastextension/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | size_mib: 123 2 | size_in_percentage: 20 3 | -------------------------------------------------------------------------------- /extension/experimental/storage/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /extension/experimental/storage/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package storage implements an extension that can 5 | // persist state beyond the collector process. 6 | package storage // import "go.opentelemetry.io/collector/extension/experimental/storage" 7 | -------------------------------------------------------------------------------- /extension/experimental/storage/nop_client.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package storage // import "go.opentelemetry.io/collector/extension/experimental/storage" 5 | 6 | import "context" 7 | 8 | type nopClient struct{} 9 | 10 | var nopClientInstance Client = &nopClient{} 11 | 12 | // NewNopClient returns a nop client 13 | func NewNopClient() Client { 14 | return nopClientInstance 15 | } 16 | 17 | // Get does nothing, and returns nil, nil 18 | func (c nopClient) Get(context.Context, string) ([]byte, error) { 19 | return nil, nil // no result, but no problem 20 | } 21 | 22 | // Set does nothing and returns nil 23 | func (c nopClient) Set(context.Context, string, []byte) error { 24 | return nil // no problem 25 | } 26 | 27 | // Delete does nothing and returns nil 28 | func (c nopClient) Delete(context.Context, string) error { 29 | return nil // no problem 30 | } 31 | 32 | // Close does nothing and returns nil 33 | func (c nopClient) Close(context.Context) error { 34 | return nil 35 | } 36 | 37 | // Batch does nothing, and returns nil, nil 38 | func (c nopClient) Batch(context.Context, ...Operation) error { 39 | return nil // no result, but no problem 40 | } 41 | -------------------------------------------------------------------------------- /extension/zpagesextension/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /extension/zpagesextension/config.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package zpagesextension // import "go.opentelemetry.io/collector/extension/zpagesextension" 5 | 6 | import ( 7 | "errors" 8 | 9 | "go.opentelemetry.io/collector/component" 10 | "go.opentelemetry.io/collector/config/confignet" 11 | ) 12 | 13 | // Config has the configuration for the extension enabling the zPages extension. 14 | type Config struct { 15 | // TCPAddr is the address and port in which the zPages will be listening to. 16 | // Use localhost: to make it available only locally, or ":" to 17 | // make it available on all network interfaces. 18 | TCPAddr confignet.TCPAddr `mapstructure:",squash"` 19 | } 20 | 21 | var _ component.Config = (*Config)(nil) 22 | 23 | // Validate checks if the extension configuration is valid 24 | func (cfg *Config) Validate() error { 25 | if cfg.TCPAddr.Endpoint == "" { 26 | return errors.New("\"endpoint\" is required when using the \"zpages\" extension") 27 | } 28 | return nil 29 | } 30 | -------------------------------------------------------------------------------- /extension/zpagesextension/config_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package zpagesextension 5 | 6 | import ( 7 | "path/filepath" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | "github.com/stretchr/testify/require" 12 | 13 | "go.opentelemetry.io/collector/component" 14 | "go.opentelemetry.io/collector/config/confignet" 15 | "go.opentelemetry.io/collector/confmap" 16 | "go.opentelemetry.io/collector/confmap/confmaptest" 17 | ) 18 | 19 | func TestUnmarshalDefaultConfig(t *testing.T) { 20 | factory := NewFactory() 21 | cfg := factory.CreateDefaultConfig() 22 | assert.NoError(t, component.UnmarshalConfig(confmap.New(), cfg)) 23 | assert.Equal(t, factory.CreateDefaultConfig(), cfg) 24 | } 25 | 26 | func TestUnmarshalConfig(t *testing.T) { 27 | cm, err := confmaptest.LoadConf(filepath.Join("testdata", "config.yaml")) 28 | require.NoError(t, err) 29 | factory := NewFactory() 30 | cfg := factory.CreateDefaultConfig() 31 | assert.NoError(t, component.UnmarshalConfig(cm, cfg)) 32 | assert.Equal(t, 33 | &Config{ 34 | TCPAddr: confignet.TCPAddr{ 35 | Endpoint: "localhost:56888", 36 | }, 37 | }, cfg) 38 | } 39 | -------------------------------------------------------------------------------- /extension/zpagesextension/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package zpagesextension implements an extension that exposes zPages of 5 | // properly instrumented components. 6 | package zpagesextension // import "go.opentelemetry.io/collector/extension/zpagesextension" 7 | -------------------------------------------------------------------------------- /extension/zpagesextension/factory.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package zpagesextension // import "go.opentelemetry.io/collector/extension/zpagesextension" 5 | 6 | import ( 7 | "context" 8 | 9 | "go.opentelemetry.io/collector/component" 10 | "go.opentelemetry.io/collector/config/confignet" 11 | "go.opentelemetry.io/collector/extension" 12 | ) 13 | 14 | const ( 15 | // The value of extension "type" in configuration. 16 | typeStr = "zpages" 17 | 18 | defaultEndpoint = "localhost:55679" 19 | ) 20 | 21 | // NewFactory creates a factory for Z-Pages extension. 22 | func NewFactory() extension.Factory { 23 | return extension.NewFactory(typeStr, createDefaultConfig, createExtension, component.StabilityLevelBeta) 24 | } 25 | 26 | func createDefaultConfig() component.Config { 27 | return &Config{ 28 | TCPAddr: confignet.TCPAddr{ 29 | Endpoint: defaultEndpoint, 30 | }, 31 | } 32 | } 33 | 34 | // createExtension creates the extension based on this config. 35 | func createExtension(_ context.Context, set extension.CreateSettings, cfg component.Config) (extension.Extension, error) { 36 | return newServer(cfg.(*Config), set.TelemetrySettings), nil 37 | } 38 | -------------------------------------------------------------------------------- /extension/zpagesextension/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | endpoint: "localhost:56888" 2 | -------------------------------------------------------------------------------- /featuregate/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /featuregate/gate_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package featuregate 5 | 6 | import ( 7 | "sync/atomic" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | ) 12 | 13 | func TestGate(t *testing.T) { 14 | enabled := &atomic.Bool{} 15 | enabled.Store(true) 16 | g := &Gate{ 17 | id: "test", 18 | description: "test gate", 19 | enabled: enabled, 20 | stage: StageAlpha, 21 | referenceURL: "http://example.com", 22 | fromVersion: "v0.61.0", 23 | toVersion: "v0.64.0", 24 | } 25 | 26 | assert.Equal(t, "test", g.ID()) 27 | assert.Equal(t, "test gate", g.Description()) 28 | assert.True(t, g.IsEnabled()) 29 | assert.Equal(t, StageAlpha, g.Stage()) 30 | assert.Equal(t, "http://example.com", g.ReferenceURL()) 31 | assert.Equal(t, "v0.61.0", g.FromVersion()) 32 | assert.Equal(t, "v0.64.0", g.ToVersion()) 33 | } 34 | -------------------------------------------------------------------------------- /featuregate/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/featuregate 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/stretchr/testify v1.8.4 7 | go.uber.org/multierr v1.11.0 8 | ) 9 | 10 | require ( 11 | github.com/davecgh/go-spew v1.1.1 // indirect 12 | github.com/kr/pretty v0.3.1 // indirect 13 | github.com/pmezard/go-difflib v1.0.0 // indirect 14 | github.com/rogpeppe/go-internal v1.10.0 // indirect 15 | gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect 16 | gopkg.in/yaml.v3 v3.0.1 // indirect 17 | ) 18 | 19 | retract ( 20 | v0.76.0 // Depends on retracted pdata v1.0.0-rc10 module, use v0.76.1 21 | v0.69.0 // Release failed, use v0.69.1 22 | ) 23 | -------------------------------------------------------------------------------- /featuregate/stage_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package featuregate 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestStageString(t *testing.T) { 13 | assert.Equal(t, "Alpha", StageAlpha.String()) 14 | assert.Equal(t, "Beta", StageBeta.String()) 15 | assert.Equal(t, "Stable", StageStable.String()) 16 | assert.Equal(t, "Deprecated", StageDeprecated.String()) 17 | assert.Equal(t, "Unknown", Stage(-1).String()) 18 | } 19 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/cpu/cpu.cfs_period_us: -------------------------------------------------------------------------------- 1 | 100000 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/cpu/cpu.cfs_quota_us: -------------------------------------------------------------------------------- 1 | 600000 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/empty/cpu.cfs_quota_us: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/internal/cgroups/testdata/cgroups/empty/cpu.cfs_quota_us -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/invalid/cpu.cfs_quota_us: -------------------------------------------------------------------------------- 1 | non-an-integer 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/memory/memory.limit_in_bytes: -------------------------------------------------------------------------------- 1 | 8796093018112 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/undefined-period/cpu.cfs_quota_us: -------------------------------------------------------------------------------- 1 | 800000 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/undefined/cpu.cfs_period_us: -------------------------------------------------------------------------------- 1 | 100000 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/undefined/cpu.cfs_quota_us: -------------------------------------------------------------------------------- 1 | -1 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/v2/empty/memory.max: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/open-telemetry/otel-arrow-collector/4f6fd1fc259a7e501930df0301639d3f8686bdf8/internal/cgroups/testdata/cgroups/v2/empty/memory.max -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/v2/invalid/memory.max: -------------------------------------------------------------------------------- 1 | ngn 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/v2/memory/memory.max: -------------------------------------------------------------------------------- 1 | 250000000 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/cgroups/v2/undefined/memory.max: -------------------------------------------------------------------------------- 1 | max 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/cgroups/cgroup: -------------------------------------------------------------------------------- 1 | 3:memory:/docker/large 2 | 2:cpu,cpuacct:/docker 3 | 1:cpuset:/ 4 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/cgroups/mountinfo: -------------------------------------------------------------------------------- 1 | 1 0 8:1 / / rw,noatime shared:1 - ext4 /dev/sda1 rw,errors=remount-ro,data=reordered 2 | 2 1 0:1 / /dev rw,relatime shared:2 - devtmpfs udev rw,size=10240k,nr_inodes=16487629,mode=755 3 | 3 1 0:2 / /proc rw,nosuid,nodev,noexec,relatime shared:3 - proc proc rw 4 | 4 1 0:3 / /sys rw,nosuid,nodev,noexec,relatime shared:4 - sysfs sysfs rw 5 | 5 4 0:4 / /sys/fs/cgroup ro,nosuid,nodev,noexec shared:5 - tmpfs tmpfs ro,mode=755 6 | 6 5 0:5 / /sys/fs/cgroup/cpuset rw,nosuid,nodev,noexec,relatime shared:6 - cgroup cgroup rw,cpuset 7 | 7 5 0:6 /docker /sys/fs/cgroup/cpu,cpuacct rw,nosuid,nodev,noexec,relatime shared:7 - cgroup cgroup rw,cpu,cpuacct 8 | 8 5 0:7 /docker /sys/fs/cgroup/memory rw,nosuid,nodev,noexec,relatime shared:8 - cgroup cgroup rw,memory 9 | 9 1 0:8 / /var/lib/docker/overlay2/9054a95f2cf7296867089e1bd37931742a17eb3308a795d51adb2654ee2276df/merged/sys/fs/cgroup ro,nosuid,nodev,noexec,relatime - tmpfs tmpfs rw,mode=755 10 | 10 9 0:9 /docker /var/lib/docker/overlay2/9054a95f2cf7296867089e1bd37931742a17eb3308a795d51adb2654ee2276df/merged/sys/fs/cgroup/memory ro,nosuid,nodev,noexec,relatime master:17 - cgroup cgroup rw,memory 11 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/invalid-cgroup/cgroup: -------------------------------------------------------------------------------- 1 | 1:cpu:/cpu 2 | invalid-line: 3 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/invalid-mountinfo/mountinfo: -------------------------------------------------------------------------------- 1 | 1 0 8:1 / / rw,noatime shared:1 - ext4 /dev/sda1 2 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/untranslatable/cgroup: -------------------------------------------------------------------------------- 1 | 1:cpu:/docker 2 | 2:cpuacct:/docker 3 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/untranslatable/mountinfo: -------------------------------------------------------------------------------- 1 | 31 23 0:24 / /sys/fs/cgroup/cpu rw,nosuid,nodev,noexec,relatime shared:1 - cgroup cgroup rw,cpu 2 | 32 23 0:25 /docker/0123456789abcdef /sys/fs/cgroup/cpuacct rw,nosuid,nodev,noexec,relatime shared:2 - cgroup cgroup rw,cpuacct 3 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/v2/cgroupv1/mountinfo: -------------------------------------------------------------------------------- 1 | 1 0 8:1 / / rw,noatime shared:1 - ext4 /dev/sda1 rw,errors=remount-ro,data=reordered 2 | 2 1 0:1 / /dev rw,relatime shared:2 - devtmpfs udev rw,size=10240k,nr_inodes=16487629,mode=755 3 | 3 1 0:2 / /proc rw,nosuid,nodev,noexec,relatime shared:3 - proc proc rw 4 | 4 1 0:3 / /sys rw,nosuid,nodev,noexec,relatime shared:4 - sysfs sysfs rw 5 | 5 4 0:4 / /sys/fs/cgroup ro,nosuid,nodev,noexec shared:5 - tmpfs tmpfs ro,mode=755 6 | 6 5 0:5 / /sys/fs/cgroup/cpuset rw,nosuid,nodev,noexec,relatime shared:6 - cgroup cgroup rw,cpuset 7 | 7 5 0:6 /docker /sys/fs/cgroup/cpu,cpuacct rw,nosuid,nodev,noexec,relatime shared:7 - cgroup cgroup rw,cpu,cpuacct 8 | 8 5 0:7 /docker /sys/fs/cgroup/memory rw,nosuid,nodev,noexec,relatime shared:8 - cgroup cgroup rw,memory 9 | -------------------------------------------------------------------------------- /internal/cgroups/testdata/proc/v2/cgroupv2/mountinfo: -------------------------------------------------------------------------------- 1 | 34 33 0:29 / /sys/fs/cgroup rw,nosuid,nodev,noexec,relatime shared:10 - cgroup2 cgroup rw,nsdelegate -------------------------------------------------------------------------------- /internal/iruntime/mem_info.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package iruntime // import "go.opentelemetry.io/collector/internal/iruntime" 5 | 6 | import ( 7 | "github.com/shirou/gopsutil/v3/mem" 8 | ) 9 | 10 | // readMemInfo returns the total memory 11 | // supports in linux, darwin and windows 12 | func readMemInfo() (uint64, error) { 13 | vmStat, err := mem.VirtualMemory() 14 | return vmStat.Total, err 15 | } 16 | -------------------------------------------------------------------------------- /internal/iruntime/mem_info_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package iruntime 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestReadMemInfo(t *testing.T) { 13 | vmStat, err := readMemInfo() 14 | assert.NoError(t, err) 15 | assert.True(t, vmStat > 0) 16 | } 17 | -------------------------------------------------------------------------------- /internal/iruntime/total_memory_linux_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | //go:build linux 5 | // +build linux 6 | 7 | package iruntime 8 | 9 | import ( 10 | "testing" 11 | 12 | "github.com/stretchr/testify/assert" 13 | "github.com/stretchr/testify/require" 14 | ) 15 | 16 | func TestTotalMemory(t *testing.T) { 17 | totalMemory, err := TotalMemory() 18 | require.NoError(t, err) 19 | assert.True(t, totalMemory > 0) 20 | } 21 | -------------------------------------------------------------------------------- /internal/iruntime/total_memory_other.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | //go:build !linux 5 | // +build !linux 6 | 7 | package iruntime // import "go.opentelemetry.io/collector/internal/iruntime" 8 | 9 | // TotalMemory returns total available memory for non-linux platforms. 10 | func TotalMemory() (uint64, error) { 11 | return readMemInfo() 12 | } 13 | -------------------------------------------------------------------------------- /internal/iruntime/total_memory_other_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | //go:build !linux 5 | // +build !linux 6 | 7 | package iruntime 8 | 9 | import ( 10 | "testing" 11 | 12 | "github.com/stretchr/testify/assert" 13 | ) 14 | 15 | func TestTotalMemory(t *testing.T) { 16 | totalMemory, err := TotalMemory() 17 | assert.NoError(t, err) 18 | assert.True(t, totalMemory > 0) 19 | } 20 | -------------------------------------------------------------------------------- /internal/obsreportconfig/obsmetrics/obsmetrics.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package obsmetrics defines the obsreport metrics for each components 5 | // all the metrics is in OpenCensus format which will be replaced with OTEL Metrics 6 | // in the future 7 | package obsmetrics // import "go.opentelemetry.io/collector/internal/obsreportconfig/obsmetrics" 8 | 9 | const ( 10 | NameSep = "/" 11 | ) 12 | -------------------------------------------------------------------------------- /internal/obsreportconfig/obsreportconfig_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package obsreportconfig 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | 11 | "go.opentelemetry.io/collector/config/configtelemetry" 12 | ) 13 | 14 | func TestConfigure(t *testing.T) { 15 | tests := []struct { 16 | name string 17 | level configtelemetry.Level 18 | wantViewsLen int 19 | }{ 20 | { 21 | name: "none", 22 | level: configtelemetry.LevelNone, 23 | }, 24 | { 25 | name: "basic", 26 | level: configtelemetry.LevelBasic, 27 | wantViewsLen: 24, 28 | }, 29 | { 30 | name: "normal", 31 | level: configtelemetry.LevelNormal, 32 | wantViewsLen: 24, 33 | }, 34 | { 35 | name: "detailed", 36 | level: configtelemetry.LevelDetailed, 37 | wantViewsLen: 24, 38 | }, 39 | } 40 | for _, tt := range tests { 41 | t.Run(tt.name, func(t *testing.T) { 42 | assert.Len(t, AllViews(tt.level), tt.wantViewsLen) 43 | }) 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /internal/testdata/common.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package testdata 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/pdata/pcommon" 8 | ) 9 | 10 | func initMetricExemplarAttributes(dest pcommon.Map) { 11 | dest.PutStr("exemplar-attachment", "exemplar-attachment-value") 12 | } 13 | 14 | func initMetricAttributes1(dest pcommon.Map) { 15 | dest.PutStr("label-1", "label-value-1") 16 | } 17 | 18 | func initMetricAttributes2(dest pcommon.Map) { 19 | dest.PutStr("label-2", "label-value-2") 20 | } 21 | 22 | func initMetricAttributes12(dest pcommon.Map) { 23 | initMetricAttributes1(dest) 24 | initMetricAttributes2(dest) 25 | } 26 | 27 | func initMetricAttributes13(dest pcommon.Map) { 28 | initMetricAttributes1(dest) 29 | dest.PutStr("label-3", "label-value-3") 30 | } 31 | -------------------------------------------------------------------------------- /internal/testdata/resource.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package testdata 5 | 6 | import "go.opentelemetry.io/collector/pdata/pcommon" 7 | 8 | func initResource(r pcommon.Resource) { 9 | r.Attributes().PutStr("resource-attr", "resource-attr-val-1") 10 | } 11 | -------------------------------------------------------------------------------- /internal/tools/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /internal/tools/empty.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package tools // import "go.opentelemetry.io/collector/internal/tools" 5 | -------------------------------------------------------------------------------- /internal/tools/jsonschema_patch.sed: -------------------------------------------------------------------------------- 1 | # go-jsonschema always generates patternProperties as 2 | # map[string]interface{}, for more specific types, they must 3 | # be replaced here 4 | s+type Headers.*+type Headers map[string]string+g -------------------------------------------------------------------------------- /obsreport/obsreport.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package obsreport // import "go.opentelemetry.io/collector/obsreport" 5 | 6 | import ( 7 | "go.opentelemetry.io/otel/codes" 8 | "go.opentelemetry.io/otel/trace" 9 | ) 10 | 11 | const ( 12 | scopeName = "go.opentelemetry.io/collector/obsreport" 13 | 14 | nameSep = "/" 15 | ) 16 | 17 | func recordError(span trace.Span, err error) { 18 | if err != nil { 19 | span.SetStatus(codes.Error, err.Error()) 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /otelcol/otelcoltest/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | nop/myreceiver: 4 | 5 | processors: 6 | nop: 7 | nop/myprocessor: 8 | 9 | exporters: 10 | nop: 11 | nop/myexporter: 12 | 13 | connectors: 14 | nop/myconnector: 15 | 16 | extensions: 17 | nop: 18 | nop/myextension: 19 | 20 | service: 21 | extensions: [nop] 22 | pipelines: 23 | traces: 24 | receivers: [nop] 25 | processors: [nop] 26 | exporters: [nop] 27 | -------------------------------------------------------------------------------- /otelcol/testdata/otelcol-invalid-components.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | exporters: 4 | nop: 5 | processors: 6 | nosuchprocessor: 7 | service: 8 | pipelines: 9 | traces: 10 | receivers: [nop] 11 | exporters: [nop] 12 | processors: [nop] 13 | -------------------------------------------------------------------------------- /otelcol/testdata/otelcol-invalid.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | 4 | processors: 5 | nop: 6 | 7 | exporters: 8 | nop: 9 | 10 | service: 11 | telemetry: 12 | metrics: 13 | address: localhost:8888 14 | pipelines: 15 | traces: 16 | receivers: [nop] 17 | processors: [invalid] 18 | exporters: [nop] 19 | -------------------------------------------------------------------------------- /otelcol/testdata/otelcol-invalidprop.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | 4 | processors: 5 | nop: 6 | 7 | exporters: 8 | nop: 9 | 10 | service: 11 | telemetry: 12 | traces: 13 | propagators: 14 | - "unknown" 15 | - "tracecontext" 16 | metrics: 17 | address: localhost:8888 18 | pipelines: 19 | traces: 20 | receivers: [nop] 21 | processors: [nop] 22 | exporters: [nop] 23 | -------------------------------------------------------------------------------- /otelcol/testdata/otelcol-noaddress.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | 4 | exporters: 5 | nop: 6 | 7 | service: 8 | telemetry: 9 | metrics: 10 | address: "" 11 | pipelines: 12 | metrics: 13 | receivers: [nop] 14 | exporters: [nop] 15 | -------------------------------------------------------------------------------- /otelcol/testdata/otelcol-nometrics.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | 4 | exporters: 5 | nop: 6 | 7 | service: 8 | telemetry: 9 | metrics: 10 | level: none 11 | pipelines: 12 | metrics: 13 | receivers: [nop] 14 | exporters: [nop] 15 | -------------------------------------------------------------------------------- /otelcol/testdata/otelcol-nop.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | 4 | processors: 5 | nop: 6 | 7 | exporters: 8 | nop: 9 | 10 | extensions: 11 | nop: 12 | 13 | connectors: 14 | nop/con: 15 | 16 | service: 17 | telemetry: 18 | metrics: 19 | address: localhost:8888 20 | extensions: [nop] 21 | pipelines: 22 | traces: 23 | receivers: [nop] 24 | processors: [nop] 25 | exporters: [nop, nop/con] 26 | metrics: 27 | receivers: [nop] 28 | processors: [nop] 29 | exporters: [nop] 30 | logs: 31 | receivers: [nop, nop/con] 32 | processors: [nop] 33 | exporters: [nop] 34 | -------------------------------------------------------------------------------- /otelcol/testdata/otelcol-validprop.yaml: -------------------------------------------------------------------------------- 1 | receivers: 2 | nop: 3 | 4 | processors: 5 | nop: 6 | 7 | exporters: 8 | nop: 9 | 10 | service: 11 | telemetry: 12 | traces: 13 | propagators: 14 | - "b3" 15 | - "tracecontext" 16 | metrics: 17 | address: localhost:8888 18 | pipelines: 19 | traces: 20 | receivers: [nop] 21 | processors: [nop] 22 | exporters: [nop] 23 | -------------------------------------------------------------------------------- /pdata/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /pdata/internal/.gitignore: -------------------------------------------------------------------------------- 1 | .patched-otlp-proto 2 | opentelemetry-proto 3 | -------------------------------------------------------------------------------- /pdata/internal/cmd/pdatagen/main.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package main 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/pdata/internal/cmd/pdatagen/internal" 8 | ) 9 | 10 | func check(e error) { 11 | if e != nil { 12 | panic(e) 13 | } 14 | } 15 | 16 | func main() { 17 | for _, fp := range internal.AllPackages { 18 | check(fp.GenerateFiles()) 19 | check(fp.GenerateTestFiles()) 20 | check(fp.GenerateInternalFiles()) 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /pdata/internal/generated_wrapper_byteslice.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. 5 | // To regenerate this file run "make genpdata". 6 | 7 | package internal 8 | 9 | type ByteSlice struct { 10 | orig *[]byte 11 | } 12 | 13 | func GetOrigByteSlice(ms ByteSlice) *[]byte { 14 | return ms.orig 15 | } 16 | 17 | func NewByteSlice(orig *[]byte) ByteSlice { 18 | return ByteSlice{orig: orig} 19 | } 20 | -------------------------------------------------------------------------------- /pdata/internal/generated_wrapper_float64slice.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. 5 | // To regenerate this file run "make genpdata". 6 | 7 | package internal 8 | 9 | type Float64Slice struct { 10 | orig *[]float64 11 | } 12 | 13 | func GetOrigFloat64Slice(ms Float64Slice) *[]float64 { 14 | return ms.orig 15 | } 16 | 17 | func NewFloat64Slice(orig *[]float64) Float64Slice { 18 | return Float64Slice{orig: orig} 19 | } 20 | -------------------------------------------------------------------------------- /pdata/internal/generated_wrapper_instrumentationscope.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. 5 | // To regenerate this file run "make genpdata". 6 | 7 | package internal 8 | 9 | import ( 10 | otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1" 11 | ) 12 | 13 | type InstrumentationScope struct { 14 | orig *otlpcommon.InstrumentationScope 15 | } 16 | 17 | func GetOrigInstrumentationScope(ms InstrumentationScope) *otlpcommon.InstrumentationScope { 18 | return ms.orig 19 | } 20 | 21 | func NewInstrumentationScope(orig *otlpcommon.InstrumentationScope) InstrumentationScope { 22 | return InstrumentationScope{orig: orig} 23 | } 24 | 25 | func GenerateTestInstrumentationScope() InstrumentationScope { 26 | orig := otlpcommon.InstrumentationScope{} 27 | tv := NewInstrumentationScope(&orig) 28 | FillTestInstrumentationScope(tv) 29 | return tv 30 | } 31 | 32 | func FillTestInstrumentationScope(tv InstrumentationScope) { 33 | tv.orig.Name = "test_name" 34 | tv.orig.Version = "test_version" 35 | FillTestMap(NewMap(&tv.orig.Attributes)) 36 | tv.orig.DroppedAttributesCount = uint32(17) 37 | } 38 | -------------------------------------------------------------------------------- /pdata/internal/generated_wrapper_resource.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. 5 | // To regenerate this file run "make genpdata". 6 | 7 | package internal 8 | 9 | import ( 10 | otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" 11 | ) 12 | 13 | type Resource struct { 14 | orig *otlpresource.Resource 15 | } 16 | 17 | func GetOrigResource(ms Resource) *otlpresource.Resource { 18 | return ms.orig 19 | } 20 | 21 | func NewResource(orig *otlpresource.Resource) Resource { 22 | return Resource{orig: orig} 23 | } 24 | 25 | func GenerateTestResource() Resource { 26 | orig := otlpresource.Resource{} 27 | tv := NewResource(&orig) 28 | FillTestResource(tv) 29 | return tv 30 | } 31 | 32 | func FillTestResource(tv Resource) { 33 | FillTestMap(NewMap(&tv.orig.Attributes)) 34 | tv.orig.DroppedAttributesCount = uint32(17) 35 | } 36 | -------------------------------------------------------------------------------- /pdata/internal/generated_wrapper_uint64slice.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. 5 | // To regenerate this file run "make genpdata". 6 | 7 | package internal 8 | 9 | type UInt64Slice struct { 10 | orig *[]uint64 11 | } 12 | 13 | func GetOrigUInt64Slice(ms UInt64Slice) *[]uint64 { 14 | return ms.orig 15 | } 16 | 17 | func NewUInt64Slice(orig *[]uint64) UInt64Slice { 18 | return UInt64Slice{orig: orig} 19 | } 20 | -------------------------------------------------------------------------------- /pdata/internal/json/enum.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package json // import "go.opentelemetry.io/collector/pdata/internal/json" 5 | 6 | import ( 7 | jsoniter "github.com/json-iterator/go" 8 | ) 9 | 10 | // ReadEnumValue returns the enum integer value representation. Accepts both enum names and enum integer values. 11 | // See https://developers.google.com/protocol-buffers/docs/proto3#json. 12 | func ReadEnumValue(iter *jsoniter.Iterator, valueMap map[string]int32) int32 { 13 | switch iter.WhatIsNext() { 14 | case jsoniter.NumberValue: 15 | return iter.ReadInt32() 16 | case jsoniter.StringValue: 17 | val, ok := valueMap[iter.ReadString()] 18 | // Same behavior with official protbuf JSON decoder, 19 | // see https://github.com/open-telemetry/opentelemetry-proto-go/pull/81 20 | if !ok { 21 | iter.ReportError("ReadEnumValue", "unknown string value") 22 | return 0 23 | } 24 | return val 25 | default: 26 | iter.ReportError("ReadEnumValue", "unsupported value type") 27 | return 0 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /pdata/internal/json/json.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package json // import "go.opentelemetry.io/collector/pdata/internal/json" 5 | 6 | import ( 7 | "io" 8 | 9 | "github.com/gogo/protobuf/jsonpb" 10 | "github.com/gogo/protobuf/proto" 11 | ) 12 | 13 | var marshaler = &jsonpb.Marshaler{ 14 | // https://github.com/open-telemetry/opentelemetry-specification/pull/2758 15 | EnumsAsInts: true, 16 | // https://github.com/open-telemetry/opentelemetry-specification/pull/2829 17 | OrigName: false, 18 | } 19 | 20 | func Marshal(out io.Writer, pb proto.Message) error { 21 | return marshaler.Marshal(out, pb) 22 | } 23 | -------------------------------------------------------------------------------- /pdata/internal/json/resource.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package json // import "go.opentelemetry.io/collector/pdata/internal/json" 5 | 6 | import ( 7 | jsoniter "github.com/json-iterator/go" 8 | 9 | otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1" 10 | ) 11 | 12 | func ReadResource(iter *jsoniter.Iterator, resource *otlpresource.Resource) { 13 | iter.ReadObjectCB(func(iter *jsoniter.Iterator, f string) bool { 14 | switch f { 15 | case "attributes": 16 | iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool { 17 | resource.Attributes = append(resource.Attributes, ReadAttribute(iter)) 18 | return true 19 | }) 20 | case "droppedAttributesCount", "dropped_attributes_count": 21 | resource.DroppedAttributesCount = ReadUint32(iter) 22 | default: 23 | iter.Skip() 24 | } 25 | return true 26 | }) 27 | } 28 | -------------------------------------------------------------------------------- /pdata/internal/json/scope.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package json // import "go.opentelemetry.io/collector/pdata/internal/json" 5 | 6 | import ( 7 | jsoniter "github.com/json-iterator/go" 8 | 9 | otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1" 10 | ) 11 | 12 | func ReadScope(iter *jsoniter.Iterator, scope *otlpcommon.InstrumentationScope) { 13 | iter.ReadObjectCB(func(iter *jsoniter.Iterator, f string) bool { 14 | switch f { 15 | case "name": 16 | scope.Name = iter.ReadString() 17 | case "version": 18 | scope.Version = iter.ReadString() 19 | case "attributes": 20 | iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool { 21 | scope.Attributes = append(scope.Attributes, ReadAttribute(iter)) 22 | return true 23 | }) 24 | case "droppedAttributesCount", "dropped_attributes_count": 25 | scope.DroppedAttributesCount = ReadUint32(iter) 26 | default: 27 | iter.Skip() 28 | } 29 | return true 30 | }) 31 | } 32 | -------------------------------------------------------------------------------- /pdata/internal/otlp/logs.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlp // import "go.opentelemetry.io/collector/pdata/internal/otlp" 5 | 6 | import ( 7 | otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1" 8 | ) 9 | 10 | // MigrateLogs implements any translation needed due to deprecation in OTLP logs protocol. 11 | // Any plog.Unmarshaler implementation from OTLP (proto/json) MUST call this, and the gRPC Server implementation. 12 | func MigrateLogs(rls []*otlplogs.ResourceLogs) { 13 | for _, rl := range rls { 14 | if len(rl.ScopeLogs) == 0 { 15 | rl.ScopeLogs = rl.DeprecatedScopeLogs 16 | } 17 | rl.DeprecatedScopeLogs = nil 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /pdata/internal/otlp/logs_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlp 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | 11 | otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1" 12 | ) 13 | 14 | func TestDeprecatedScopeLogs(t *testing.T) { 15 | sl := new(otlplogs.ScopeLogs) 16 | rls := []*otlplogs.ResourceLogs{ 17 | { 18 | ScopeLogs: []*otlplogs.ScopeLogs{sl}, 19 | DeprecatedScopeLogs: []*otlplogs.ScopeLogs{sl}, 20 | }, 21 | { 22 | ScopeLogs: []*otlplogs.ScopeLogs{}, 23 | DeprecatedScopeLogs: []*otlplogs.ScopeLogs{sl}, 24 | }, 25 | } 26 | 27 | MigrateLogs(rls) 28 | assert.Same(t, sl, rls[0].ScopeLogs[0]) 29 | assert.Same(t, sl, rls[1].ScopeLogs[0]) 30 | assert.Nil(t, rls[0].DeprecatedScopeLogs) 31 | assert.Nil(t, rls[0].DeprecatedScopeLogs) 32 | } 33 | -------------------------------------------------------------------------------- /pdata/internal/otlp/metrics.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlp // import "go.opentelemetry.io/collector/pdata/internal/otlp" 5 | 6 | import ( 7 | otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1" 8 | ) 9 | 10 | // MigrateMetrics implements any translation needed due to deprecation in OTLP metrics protocol. 11 | // Any pmetric.Unmarshaler implementation from OTLP (proto/json) MUST call this, and the gRPC Server implementation. 12 | func MigrateMetrics(rms []*otlpmetrics.ResourceMetrics) { 13 | for _, rm := range rms { 14 | if len(rm.ScopeMetrics) == 0 { 15 | rm.ScopeMetrics = rm.DeprecatedScopeMetrics 16 | } 17 | rm.DeprecatedScopeMetrics = nil 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /pdata/internal/otlp/metrics_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlp 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | 11 | otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1" 12 | ) 13 | 14 | func TestDeprecatedScopeMetrics(t *testing.T) { 15 | sm := new(otlpmetrics.ScopeMetrics) 16 | rms := []*otlpmetrics.ResourceMetrics{ 17 | { 18 | ScopeMetrics: []*otlpmetrics.ScopeMetrics{sm}, 19 | DeprecatedScopeMetrics: []*otlpmetrics.ScopeMetrics{sm}, 20 | }, 21 | { 22 | ScopeMetrics: []*otlpmetrics.ScopeMetrics{}, 23 | DeprecatedScopeMetrics: []*otlpmetrics.ScopeMetrics{sm}, 24 | }, 25 | } 26 | 27 | MigrateMetrics(rms) 28 | assert.Same(t, sm, rms[0].ScopeMetrics[0]) 29 | assert.Same(t, sm, rms[1].ScopeMetrics[0]) 30 | assert.Nil(t, rms[0].DeprecatedScopeMetrics) 31 | assert.Nil(t, rms[0].DeprecatedScopeMetrics) 32 | } 33 | -------------------------------------------------------------------------------- /pdata/internal/otlp/traces.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlp // import "go.opentelemetry.io/collector/pdata/internal/otlp" 5 | 6 | import ( 7 | otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1" 8 | ) 9 | 10 | // MigrateTraces implements any translation needed due to deprecation in OTLP traces protocol. 11 | // Any ptrace.Unmarshaler implementation from OTLP (proto/json) MUST call this, and the gRPC Server implementation. 12 | func MigrateTraces(rss []*otlptrace.ResourceSpans) { 13 | for _, rs := range rss { 14 | if len(rs.ScopeSpans) == 0 { 15 | rs.ScopeSpans = rs.DeprecatedScopeSpans 16 | } 17 | rs.DeprecatedScopeSpans = nil 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /pdata/internal/otlp/traces_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package otlp 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | 11 | otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1" 12 | ) 13 | 14 | func TestDeprecatedScopeSpans(t *testing.T) { 15 | ss := new(otlptrace.ScopeSpans) 16 | rss := []*otlptrace.ResourceSpans{ 17 | { 18 | ScopeSpans: []*otlptrace.ScopeSpans{ss}, 19 | DeprecatedScopeSpans: []*otlptrace.ScopeSpans{ss}, 20 | }, 21 | { 22 | ScopeSpans: []*otlptrace.ScopeSpans{}, 23 | DeprecatedScopeSpans: []*otlptrace.ScopeSpans{ss}, 24 | }, 25 | } 26 | 27 | MigrateTraces(rss) 28 | assert.Same(t, ss, rss[0].ScopeSpans[0]) 29 | assert.Same(t, ss, rss[1].ScopeSpans[0]) 30 | assert.Nil(t, rss[0].DeprecatedScopeSpans) 31 | assert.Nil(t, rss[0].DeprecatedScopeSpans) 32 | } 33 | -------------------------------------------------------------------------------- /pdata/internal/wrapper_logs.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/pdata/internal" 5 | 6 | import ( 7 | otlpcollectorlog "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1" 8 | otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1" 9 | ) 10 | 11 | type Logs struct { 12 | orig *otlpcollectorlog.ExportLogsServiceRequest 13 | } 14 | 15 | func GetOrigLogs(ms Logs) *otlpcollectorlog.ExportLogsServiceRequest { 16 | return ms.orig 17 | } 18 | 19 | func NewLogs(orig *otlpcollectorlog.ExportLogsServiceRequest) Logs { 20 | return Logs{orig: orig} 21 | } 22 | 23 | // LogsToProto internal helper to convert Logs to protobuf representation. 24 | func LogsToProto(l Logs) otlplogs.LogsData { 25 | return otlplogs.LogsData{ 26 | ResourceLogs: l.orig.ResourceLogs, 27 | } 28 | } 29 | 30 | // LogsFromProto internal helper to convert protobuf representation to Logs. 31 | func LogsFromProto(orig otlplogs.LogsData) Logs { 32 | return Logs{orig: &otlpcollectorlog.ExportLogsServiceRequest{ 33 | ResourceLogs: orig.ResourceLogs, 34 | }} 35 | } 36 | -------------------------------------------------------------------------------- /pdata/internal/wrapper_map.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/pdata/internal" 5 | 6 | import ( 7 | otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1" 8 | ) 9 | 10 | type Map struct { 11 | orig *[]otlpcommon.KeyValue 12 | } 13 | 14 | func GetOrigMap(ms Map) *[]otlpcommon.KeyValue { 15 | return ms.orig 16 | } 17 | 18 | func NewMap(orig *[]otlpcommon.KeyValue) Map { 19 | return Map{orig: orig} 20 | } 21 | 22 | func GenerateTestMap() Map { 23 | var orig []otlpcommon.KeyValue 24 | ms := NewMap(&orig) 25 | FillTestMap(ms) 26 | return ms 27 | } 28 | 29 | func FillTestMap(dest Map) { 30 | *dest.orig = nil 31 | *dest.orig = append(*dest.orig, otlpcommon.KeyValue{Key: "k", Value: otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "v"}}}) 32 | } 33 | -------------------------------------------------------------------------------- /pdata/internal/wrapper_slice.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/pdata/internal" 5 | 6 | import ( 7 | otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1" 8 | ) 9 | 10 | type Slice struct { 11 | orig *[]otlpcommon.AnyValue 12 | } 13 | 14 | func GetOrigSlice(ms Slice) *[]otlpcommon.AnyValue { 15 | return ms.orig 16 | } 17 | 18 | func NewSlice(orig *[]otlpcommon.AnyValue) Slice { 19 | return Slice{orig: orig} 20 | } 21 | 22 | func GenerateTestSlice() Slice { 23 | orig := []otlpcommon.AnyValue{} 24 | tv := NewSlice(&orig) 25 | FillTestSlice(tv) 26 | return tv 27 | } 28 | 29 | func FillTestSlice(tv Slice) { 30 | *tv.orig = make([]otlpcommon.AnyValue, 7) 31 | for i := 0; i < 7; i++ { 32 | FillTestValue(NewValue(&(*tv.orig)[i])) 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /pdata/internal/wrapper_traces.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/pdata/internal" 5 | 6 | import ( 7 | otlpcollectortrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/trace/v1" 8 | otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1" 9 | ) 10 | 11 | type Traces struct { 12 | orig *otlpcollectortrace.ExportTraceServiceRequest 13 | } 14 | 15 | func GetOrigTraces(ms Traces) *otlpcollectortrace.ExportTraceServiceRequest { 16 | return ms.orig 17 | } 18 | 19 | func NewTraces(orig *otlpcollectortrace.ExportTraceServiceRequest) Traces { 20 | return Traces{orig: orig} 21 | } 22 | 23 | // TracesToProto internal helper to convert Traces to protobuf representation. 24 | func TracesToProto(l Traces) otlptrace.TracesData { 25 | return otlptrace.TracesData{ 26 | ResourceSpans: l.orig.ResourceSpans, 27 | } 28 | } 29 | 30 | // TracesFromProto internal helper to convert protobuf representation to Traces. 31 | func TracesFromProto(orig otlptrace.TracesData) Traces { 32 | return Traces{orig: &otlpcollectortrace.ExportTraceServiceRequest{ 33 | ResourceSpans: orig.ResourceSpans, 34 | }} 35 | } 36 | -------------------------------------------------------------------------------- /pdata/internal/wrapper_tracestate.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/pdata/internal" 5 | 6 | type TraceState struct { 7 | orig *string 8 | } 9 | 10 | func GetOrigTraceState(ms TraceState) *string { 11 | return ms.orig 12 | } 13 | 14 | func NewTraceState(orig *string) TraceState { 15 | return TraceState{orig: orig} 16 | } 17 | 18 | func GenerateTestTraceState() TraceState { 19 | var orig string 20 | ms := NewTraceState(&orig) 21 | FillTestTraceState(ms) 22 | return ms 23 | } 24 | 25 | func FillTestTraceState(dest TraceState) { 26 | *dest.orig = "rojo=00f067aa0ba902b7" 27 | } 28 | -------------------------------------------------------------------------------- /pdata/internal/wrapper_value.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package internal // import "go.opentelemetry.io/collector/pdata/internal" 5 | 6 | import ( 7 | otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1" 8 | ) 9 | 10 | type Value struct { 11 | orig *otlpcommon.AnyValue 12 | } 13 | 14 | func GetOrigValue(ms Value) *otlpcommon.AnyValue { 15 | return ms.orig 16 | } 17 | 18 | func NewValue(orig *otlpcommon.AnyValue) Value { 19 | return Value{orig: orig} 20 | } 21 | 22 | func FillTestValue(dest Value) { 23 | dest.orig.Value = &otlpcommon.AnyValue_StringValue{StringValue: "v"} 24 | } 25 | 26 | func GenerateTestValue() Value { 27 | var orig otlpcommon.AnyValue 28 | ms := NewValue(&orig) 29 | FillTestValue(ms) 30 | return ms 31 | } 32 | -------------------------------------------------------------------------------- /pdata/pcommon/spanid.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pcommon // import "go.opentelemetry.io/collector/pdata/pcommon" 5 | import ( 6 | "encoding/hex" 7 | 8 | "go.opentelemetry.io/collector/pdata/internal/data" 9 | ) 10 | 11 | var emptySpanID = SpanID([8]byte{}) 12 | 13 | // SpanID is span identifier. 14 | type SpanID [8]byte 15 | 16 | // NewSpanIDEmpty returns a new empty (all zero bytes) SpanID. 17 | func NewSpanIDEmpty() SpanID { 18 | return emptySpanID 19 | } 20 | 21 | // String returns string representation of the SpanID. 22 | // 23 | // Important: Don't rely on this method to get a string identifier of SpanID, 24 | // Use hex.EncodeToString explicitly instead. 25 | // This method meant to implement Stringer interface for display purposes only. 26 | func (ms SpanID) String() string { 27 | if ms.IsEmpty() { 28 | return "" 29 | } 30 | return hex.EncodeToString(ms[:]) 31 | } 32 | 33 | // IsEmpty returns true if id doesn't contain at least one non-zero byte. 34 | func (ms SpanID) IsEmpty() bool { 35 | return data.SpanID(ms).IsEmpty() 36 | } 37 | -------------------------------------------------------------------------------- /pdata/pcommon/spanid_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pcommon 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestSpanID(t *testing.T) { 13 | sid := SpanID([8]byte{1, 2, 3, 4, 4, 3, 2, 1}) 14 | assert.Equal(t, [8]byte{1, 2, 3, 4, 4, 3, 2, 1}, [8]byte(sid)) 15 | assert.False(t, sid.IsEmpty()) 16 | } 17 | 18 | func TestNewSpanIDEmpty(t *testing.T) { 19 | sid := NewSpanIDEmpty() 20 | assert.Equal(t, [8]byte{}, [8]byte(sid)) 21 | assert.True(t, sid.IsEmpty()) 22 | } 23 | 24 | func TestSpanIDString(t *testing.T) { 25 | sid := SpanID([8]byte{}) 26 | assert.Equal(t, "", sid.String()) 27 | 28 | sid = SpanID([8]byte{0x12, 0x23, 0xAD, 0x12, 0x23, 0xAD, 0x12, 0x23}) 29 | assert.Equal(t, "1223ad1223ad1223", sid.String()) 30 | } 31 | 32 | func TestSpanIDImmutable(t *testing.T) { 33 | initialBytes := [8]byte{0x12, 0x23, 0xAD, 0x12, 0x23, 0xAD, 0x12, 0x23} 34 | sid := SpanID(initialBytes) 35 | assert.Equal(t, SpanID(initialBytes), sid) 36 | 37 | // Get the bytes and try to mutate. 38 | sid[4] = 0x89 39 | 40 | // Does not change the already created SpanID. 41 | assert.NotEqual(t, SpanID(initialBytes), sid) 42 | } 43 | -------------------------------------------------------------------------------- /pdata/pcommon/timestamp.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pcommon // import "go.opentelemetry.io/collector/pdata/pcommon" 5 | 6 | import ( 7 | "time" 8 | ) 9 | 10 | // Timestamp is a time specified as UNIX Epoch time in nanoseconds since 11 | // 1970-01-01 00:00:00 +0000 UTC. 12 | type Timestamp uint64 13 | 14 | // NewTimestampFromTime constructs a new Timestamp from the provided time.Time. 15 | func NewTimestampFromTime(t time.Time) Timestamp { 16 | return Timestamp(uint64(t.UnixNano())) 17 | } 18 | 19 | // AsTime converts this to a time.Time. 20 | func (ts Timestamp) AsTime() time.Time { 21 | return time.Unix(0, int64(ts)).UTC() 22 | } 23 | 24 | // String returns the string representation of this in UTC. 25 | func (ts Timestamp) String() string { 26 | return ts.AsTime().String() 27 | } 28 | -------------------------------------------------------------------------------- /pdata/pcommon/timestamp_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pcommon 5 | 6 | import ( 7 | "testing" 8 | "time" 9 | 10 | "github.com/stretchr/testify/assert" 11 | ) 12 | 13 | func TestUnixNanosConverters(t *testing.T) { 14 | t1 := time.Date(2020, 03, 24, 1, 13, 23, 789, time.UTC) 15 | tun := Timestamp(t1.UnixNano()) 16 | 17 | assert.EqualValues(t, uint64(1585012403000000789), tun) 18 | assert.EqualValues(t, tun, NewTimestampFromTime(t1)) 19 | assert.EqualValues(t, t1, NewTimestampFromTime(t1).AsTime()) 20 | assert.Equal(t, "2020-03-24 01:13:23.000000789 +0000 UTC", t1.String()) 21 | } 22 | 23 | func TestZeroTimestamp(t *testing.T) { 24 | assert.Equal(t, time.Unix(0, 0).UTC(), Timestamp(0).AsTime()) 25 | assert.Zero(t, NewTimestampFromTime(time.Unix(0, 0).UTC())) 26 | assert.Equal(t, "1970-01-01 00:00:00 +0000 UTC", Timestamp(0).String()) 27 | } 28 | -------------------------------------------------------------------------------- /pdata/pcommon/trace_state_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pcommon 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | 11 | "go.opentelemetry.io/collector/pdata/internal" 12 | ) 13 | 14 | func TestTraceState_MoveTo(t *testing.T) { 15 | ms := TraceState(internal.GenerateTestTraceState()) 16 | dest := NewTraceState() 17 | ms.MoveTo(dest) 18 | assert.Equal(t, NewTraceState(), ms) 19 | assert.Equal(t, TraceState(internal.GenerateTestTraceState()), dest) 20 | } 21 | 22 | func TestTraceState_CopyTo(t *testing.T) { 23 | ms := NewTraceState() 24 | orig := NewTraceState() 25 | orig.CopyTo(ms) 26 | assert.Equal(t, orig, ms) 27 | orig = TraceState(internal.GenerateTestTraceState()) 28 | orig.CopyTo(ms) 29 | assert.Equal(t, orig, ms) 30 | } 31 | 32 | func TestTraceState_FromRaw_AsRaw(t *testing.T) { 33 | ms := NewTraceState() 34 | assert.Equal(t, "", ms.AsRaw()) 35 | ms.FromRaw("congo=t61rcWkgMzE") 36 | assert.Equal(t, "congo=t61rcWkgMzE", ms.AsRaw()) 37 | } 38 | -------------------------------------------------------------------------------- /pdata/pcommon/traceid.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pcommon // import "go.opentelemetry.io/collector/pdata/pcommon" 5 | 6 | import ( 7 | "encoding/hex" 8 | 9 | "go.opentelemetry.io/collector/pdata/internal/data" 10 | ) 11 | 12 | var emptyTraceID = TraceID([16]byte{}) 13 | 14 | // TraceID is a trace identifier. 15 | type TraceID [16]byte 16 | 17 | // NewTraceIDEmpty returns a new empty (all zero bytes) TraceID. 18 | func NewTraceIDEmpty() TraceID { 19 | return emptyTraceID 20 | } 21 | 22 | // String returns string representation of the TraceID. 23 | // 24 | // Important: Don't rely on this method to get a string identifier of TraceID. 25 | // Use hex.EncodeToString explicitly instead. 26 | // This method meant to implement Stringer interface for display purposes only. 27 | func (ms TraceID) String() string { 28 | if ms.IsEmpty() { 29 | return "" 30 | } 31 | return hex.EncodeToString(ms[:]) 32 | } 33 | 34 | // IsEmpty returns true if id doesn't contain at least one non-zero byte. 35 | func (ms TraceID) IsEmpty() bool { 36 | return data.TraceID(ms).IsEmpty() 37 | } 38 | -------------------------------------------------------------------------------- /pdata/plog/encoding.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package plog // import "go.opentelemetry.io/collector/pdata/plog" 5 | 6 | // MarshalSizer is the interface that groups the basic Marshal and Size methods 7 | type MarshalSizer interface { 8 | Marshaler 9 | Sizer 10 | } 11 | 12 | // Marshaler marshals pdata.Logs into bytes. 13 | type Marshaler interface { 14 | // MarshalLogs the given pdata.Logs into bytes. 15 | // If the error is not nil, the returned bytes slice cannot be used. 16 | MarshalLogs(ld Logs) ([]byte, error) 17 | } 18 | 19 | // Unmarshaler unmarshalls bytes into pdata.Logs. 20 | type Unmarshaler interface { 21 | // UnmarshalLogs the given bytes into pdata.Logs. 22 | // If the error is not nil, the returned pdata.Logs cannot be used. 23 | UnmarshalLogs(buf []byte) (Logs, error) 24 | } 25 | 26 | // Sizer is an optional interface implemented by the Marshaler, 27 | // that calculates the size of a marshaled Logs. 28 | type Sizer interface { 29 | // LogsSize returns the size in bytes of a marshaled Logs. 30 | LogsSize(ld Logs) int 31 | } 32 | -------------------------------------------------------------------------------- /pdata/plog/log_record_flags.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package plog // import "go.opentelemetry.io/collector/pdata/plog" 5 | 6 | const isSampledMask = uint32(1) 7 | 8 | var DefaultLogRecordFlags = LogRecordFlags(0) 9 | 10 | // LogRecordFlags defines flags for the LogRecord. The 8 least significant bits are the trace flags as 11 | // defined in W3C Trace Context specification. 24 most significant bits are reserved and must be set to 0. 12 | type LogRecordFlags uint32 13 | 14 | // IsSampled returns true if the LogRecordFlags contains the IsSampled flag. 15 | func (ms LogRecordFlags) IsSampled() bool { 16 | return uint32(ms)&isSampledMask != 0 17 | } 18 | 19 | // WithIsSampled returns a new LogRecordFlags, with the IsSampled flag set to the given value. 20 | func (ms LogRecordFlags) WithIsSampled(b bool) LogRecordFlags { 21 | orig := uint32(ms) 22 | if b { 23 | orig |= isSampledMask 24 | } else { 25 | orig &^= isSampledMask 26 | } 27 | return LogRecordFlags(orig) 28 | } 29 | -------------------------------------------------------------------------------- /pdata/plog/log_record_flags_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package plog 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestLogRecordFlags(t *testing.T) { 13 | flags := LogRecordFlags(1) 14 | assert.True(t, flags.IsSampled()) 15 | assert.EqualValues(t, uint32(1), flags) 16 | 17 | flags = flags.WithIsSampled(false) 18 | assert.False(t, flags.IsSampled()) 19 | assert.EqualValues(t, uint32(0), flags) 20 | 21 | flags = flags.WithIsSampled(true) 22 | assert.True(t, flags.IsSampled()) 23 | assert.EqualValues(t, uint32(1), flags) 24 | } 25 | 26 | func TestDefaultLogRecordFlags(t *testing.T) { 27 | flags := DefaultLogRecordFlags 28 | assert.False(t, flags.IsSampled()) 29 | assert.EqualValues(t, uint32(0), flags) 30 | } 31 | -------------------------------------------------------------------------------- /pdata/plog/pb.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package plog // import "go.opentelemetry.io/collector/pdata/plog" 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/pdata/internal" 8 | otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1" 9 | ) 10 | 11 | var _ MarshalSizer = (*ProtoMarshaler)(nil) 12 | 13 | type ProtoMarshaler struct{} 14 | 15 | func (e *ProtoMarshaler) MarshalLogs(ld Logs) ([]byte, error) { 16 | pb := internal.LogsToProto(internal.Logs(ld)) 17 | return pb.Marshal() 18 | } 19 | 20 | func (e *ProtoMarshaler) LogsSize(ld Logs) int { 21 | pb := internal.LogsToProto(internal.Logs(ld)) 22 | return pb.Size() 23 | } 24 | 25 | var _ Unmarshaler = (*ProtoUnmarshaler)(nil) 26 | 27 | type ProtoUnmarshaler struct{} 28 | 29 | func (d *ProtoUnmarshaler) UnmarshalLogs(buf []byte) (Logs, error) { 30 | pb := otlplogs.LogsData{} 31 | err := pb.Unmarshal(buf) 32 | return Logs(internal.LogsFromProto(pb)), err 33 | } 34 | -------------------------------------------------------------------------------- /pdata/pmetric/aggregation_temporality_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestAggregationTemporalityString(t *testing.T) { 13 | assert.Equal(t, "Unspecified", AggregationTemporalityUnspecified.String()) 14 | assert.Equal(t, "Delta", AggregationTemporalityDelta.String()) 15 | assert.Equal(t, "Cumulative", AggregationTemporalityCumulative.String()) 16 | assert.Equal(t, "", (AggregationTemporalityCumulative + 1).String()) 17 | } 18 | -------------------------------------------------------------------------------- /pdata/pmetric/encoding.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | // MarshalSizer is the interface that groups the basic Marshal and Size methods 7 | type MarshalSizer interface { 8 | Marshaler 9 | Sizer 10 | } 11 | 12 | // Marshaler marshals pmetric.Metrics into bytes. 13 | type Marshaler interface { 14 | // MarshalMetrics the given pmetric.Metrics into bytes. 15 | // If the error is not nil, the returned bytes slice cannot be used. 16 | MarshalMetrics(md Metrics) ([]byte, error) 17 | } 18 | 19 | // Unmarshaler unmarshalls bytes into pmetric.Metrics. 20 | type Unmarshaler interface { 21 | // UnmarshalMetrics the given bytes into pmetric.Metrics. 22 | // If the error is not nil, the returned pmetric.Metrics cannot be used. 23 | UnmarshalMetrics(buf []byte) (Metrics, error) 24 | } 25 | 26 | // Sizer is an optional interface implemented by the Marshaler, that calculates the size of a marshaled Metrics. 27 | type Sizer interface { 28 | // MetricsSize returns the size in bytes of a marshaled Metrics. 29 | MetricsSize(md Metrics) int 30 | } 31 | -------------------------------------------------------------------------------- /pdata/pmetric/exemplar_value_type.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | // ExemplarValueType specifies the type of Exemplar measurement value. 7 | type ExemplarValueType int32 8 | 9 | const ( 10 | // ExemplarValueTypeEmpty means that exemplar value is unset. 11 | ExemplarValueTypeEmpty ExemplarValueType = iota 12 | ExemplarValueTypeInt 13 | ExemplarValueTypeDouble 14 | ) 15 | 16 | // String returns the string representation of the ExemplarValueType. 17 | func (nt ExemplarValueType) String() string { 18 | switch nt { 19 | case ExemplarValueTypeEmpty: 20 | return "Empty" 21 | case ExemplarValueTypeInt: 22 | return "Int" 23 | case ExemplarValueTypeDouble: 24 | return "Double" 25 | } 26 | return "" 27 | } 28 | -------------------------------------------------------------------------------- /pdata/pmetric/exemplar_value_type_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestExemplarValueTypeString(t *testing.T) { 13 | assert.Equal(t, "Empty", ExemplarValueTypeEmpty.String()) 14 | assert.Equal(t, "Int", ExemplarValueTypeInt.String()) 15 | assert.Equal(t, "Double", ExemplarValueTypeDouble.String()) 16 | assert.Equal(t, "", (ExemplarValueTypeDouble + 1).String()) 17 | } 18 | -------------------------------------------------------------------------------- /pdata/pmetric/metric_data_point_flags.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | const noRecordValueMask = uint32(1) 7 | 8 | var DefaultDataPointFlags = DataPointFlags(0) 9 | 10 | // DataPointFlags defines how a metric aggregator reports aggregated values. 11 | // It describes how those values relate to the time interval over which they are aggregated. 12 | type DataPointFlags uint32 13 | 14 | // NoRecordedValue returns true if the DataPointFlags contains the NoRecordedValue flag. 15 | func (ms DataPointFlags) NoRecordedValue() bool { 16 | return uint32(ms)&noRecordValueMask != 0 17 | } 18 | 19 | // WithNoRecordedValue returns a new DataPointFlags, with the NoRecordedValue flag set to the given value. 20 | func (ms DataPointFlags) WithNoRecordedValue(b bool) DataPointFlags { 21 | orig := uint32(ms) 22 | if b { 23 | orig |= noRecordValueMask 24 | } else { 25 | orig &^= noRecordValueMask 26 | } 27 | return DataPointFlags(orig) 28 | } 29 | -------------------------------------------------------------------------------- /pdata/pmetric/metric_data_point_flags_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestLogRecordFlags(t *testing.T) { 13 | flags := DataPointFlags(1) 14 | assert.True(t, flags.NoRecordedValue()) 15 | assert.EqualValues(t, uint32(1), flags) 16 | 17 | flags = flags.WithNoRecordedValue(false) 18 | assert.False(t, flags.NoRecordedValue()) 19 | assert.EqualValues(t, uint32(0), flags) 20 | 21 | flags = flags.WithNoRecordedValue(true) 22 | assert.True(t, flags.NoRecordedValue()) 23 | assert.EqualValues(t, uint32(1), flags) 24 | } 25 | 26 | func TestDefaultLogRecordFlags(t *testing.T) { 27 | flags := DefaultDataPointFlags 28 | assert.False(t, flags.NoRecordedValue()) 29 | assert.EqualValues(t, uint32(0), flags) 30 | } 31 | -------------------------------------------------------------------------------- /pdata/pmetric/metric_type.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | // MetricType specifies the type of data in a Metric. 7 | type MetricType int32 8 | 9 | const ( 10 | // MetricTypeEmpty means that metric type is unset. 11 | MetricTypeEmpty MetricType = iota 12 | MetricTypeGauge 13 | MetricTypeSum 14 | MetricTypeHistogram 15 | MetricTypeExponentialHistogram 16 | MetricTypeSummary 17 | ) 18 | 19 | // String returns the string representation of the MetricType. 20 | func (mdt MetricType) String() string { 21 | switch mdt { 22 | case MetricTypeEmpty: 23 | return "Empty" 24 | case MetricTypeGauge: 25 | return "Gauge" 26 | case MetricTypeSum: 27 | return "Sum" 28 | case MetricTypeHistogram: 29 | return "Histogram" 30 | case MetricTypeExponentialHistogram: 31 | return "ExponentialHistogram" 32 | case MetricTypeSummary: 33 | return "Summary" 34 | } 35 | return "" 36 | } 37 | -------------------------------------------------------------------------------- /pdata/pmetric/metric_type_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestMetricTypeString(t *testing.T) { 13 | assert.Equal(t, "Empty", MetricTypeEmpty.String()) 14 | assert.Equal(t, "Gauge", MetricTypeGauge.String()) 15 | assert.Equal(t, "Sum", MetricTypeSum.String()) 16 | assert.Equal(t, "Histogram", MetricTypeHistogram.String()) 17 | assert.Equal(t, "ExponentialHistogram", MetricTypeExponentialHistogram.String()) 18 | assert.Equal(t, "Summary", MetricTypeSummary.String()) 19 | assert.Equal(t, "", (MetricTypeSummary + 1).String()) 20 | } 21 | -------------------------------------------------------------------------------- /pdata/pmetric/number_data_point_value_type.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | // NumberDataPointValueType specifies the type of NumberDataPoint value. 7 | type NumberDataPointValueType int32 8 | 9 | const ( 10 | // NumberDataPointValueTypeEmpty means that data point value is unset. 11 | NumberDataPointValueTypeEmpty NumberDataPointValueType = iota 12 | NumberDataPointValueTypeInt 13 | NumberDataPointValueTypeDouble 14 | ) 15 | 16 | // String returns the string representation of the NumberDataPointValueType. 17 | func (nt NumberDataPointValueType) String() string { 18 | switch nt { 19 | case NumberDataPointValueTypeEmpty: 20 | return "Empty" 21 | case NumberDataPointValueTypeInt: 22 | return "Int" 23 | case NumberDataPointValueTypeDouble: 24 | return "Double" 25 | } 26 | return "" 27 | } 28 | -------------------------------------------------------------------------------- /pdata/pmetric/number_data_point_value_type_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestNumberDataPointValueTypeString(t *testing.T) { 13 | assert.Equal(t, "Empty", NumberDataPointValueTypeEmpty.String()) 14 | assert.Equal(t, "Int", NumberDataPointValueTypeInt.String()) 15 | assert.Equal(t, "Double", NumberDataPointValueTypeDouble.String()) 16 | assert.Equal(t, "", (NumberDataPointValueTypeDouble + 1).String()) 17 | } 18 | -------------------------------------------------------------------------------- /pdata/pmetric/pb.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package pmetric // import "go.opentelemetry.io/collector/pdata/pmetric" 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/pdata/internal" 8 | otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1" 9 | ) 10 | 11 | var _ MarshalSizer = (*ProtoMarshaler)(nil) 12 | 13 | type ProtoMarshaler struct{} 14 | 15 | func (e *ProtoMarshaler) MarshalMetrics(md Metrics) ([]byte, error) { 16 | pb := internal.MetricsToProto(internal.Metrics(md)) 17 | return pb.Marshal() 18 | } 19 | 20 | func (e *ProtoMarshaler) MetricsSize(md Metrics) int { 21 | pb := internal.MetricsToProto(internal.Metrics(md)) 22 | return pb.Size() 23 | } 24 | 25 | type ProtoUnmarshaler struct{} 26 | 27 | func (d *ProtoUnmarshaler) UnmarshalMetrics(buf []byte) (Metrics, error) { 28 | pb := otlpmetrics.MetricsData{} 29 | err := pb.Unmarshal(buf) 30 | return Metrics(internal.MetricsFromProto(pb)), err 31 | } 32 | -------------------------------------------------------------------------------- /pdata/ptrace/encoding.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ptrace // import "go.opentelemetry.io/collector/pdata/ptrace" 5 | 6 | // MarshalSizer is the interface that groups the basic Marshal and Size methods 7 | type MarshalSizer interface { 8 | Marshaler 9 | Sizer 10 | } 11 | 12 | // Marshaler marshals pdata.Traces into bytes. 13 | type Marshaler interface { 14 | // MarshalTraces the given pdata.Traces into bytes. 15 | // If the error is not nil, the returned bytes slice cannot be used. 16 | MarshalTraces(td Traces) ([]byte, error) 17 | } 18 | 19 | // Unmarshaler unmarshalls bytes into pdata.Traces. 20 | type Unmarshaler interface { 21 | // UnmarshalTraces the given bytes into pdata.Traces. 22 | // If the error is not nil, the returned pdata.Traces cannot be used. 23 | UnmarshalTraces(buf []byte) (Traces, error) 24 | } 25 | 26 | // Sizer is an optional interface implemented by the Marshaler, 27 | // that calculates the size of a marshaled Traces. 28 | type Sizer interface { 29 | // TracesSize returns the size in bytes of a marshaled Traces. 30 | TracesSize(td Traces) int 31 | } 32 | -------------------------------------------------------------------------------- /pdata/ptrace/pb.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ptrace // import "go.opentelemetry.io/collector/pdata/ptrace" 5 | 6 | import ( 7 | "go.opentelemetry.io/collector/pdata/internal" 8 | otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1" 9 | ) 10 | 11 | var _ MarshalSizer = (*ProtoMarshaler)(nil) 12 | 13 | type ProtoMarshaler struct{} 14 | 15 | func (e *ProtoMarshaler) MarshalTraces(td Traces) ([]byte, error) { 16 | pb := internal.TracesToProto(internal.Traces(td)) 17 | return pb.Marshal() 18 | } 19 | 20 | func (e *ProtoMarshaler) TracesSize(td Traces) int { 21 | pb := internal.TracesToProto(internal.Traces(td)) 22 | return pb.Size() 23 | } 24 | 25 | type ProtoUnmarshaler struct{} 26 | 27 | func (d *ProtoUnmarshaler) UnmarshalTraces(buf []byte) (Traces, error) { 28 | pb := otlptrace.TracesData{} 29 | err := pb.Unmarshal(buf) 30 | return Traces(internal.TracesFromProto(pb)), err 31 | } 32 | -------------------------------------------------------------------------------- /pdata/ptrace/span_kind_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ptrace // import "go.opentelemetry.io/collector/pdata/ptrace" 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestSpanKindString(t *testing.T) { 13 | assert.EqualValues(t, "Unspecified", SpanKindUnspecified.String()) 14 | assert.EqualValues(t, "Internal", SpanKindInternal.String()) 15 | assert.EqualValues(t, "Server", SpanKindServer.String()) 16 | assert.EqualValues(t, "Client", SpanKindClient.String()) 17 | assert.EqualValues(t, "Producer", SpanKindProducer.String()) 18 | assert.EqualValues(t, "Consumer", SpanKindConsumer.String()) 19 | assert.EqualValues(t, "", SpanKind(100).String()) 20 | } 21 | -------------------------------------------------------------------------------- /pdata/ptrace/status_code.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ptrace // import "go.opentelemetry.io/collector/pdata/ptrace" 5 | 6 | import ( 7 | otlptrace "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1" 8 | ) 9 | 10 | // StatusCode mirrors the codes defined at 11 | // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#set-status 12 | type StatusCode int32 13 | 14 | const ( 15 | StatusCodeUnset = StatusCode(otlptrace.Status_STATUS_CODE_UNSET) 16 | StatusCodeOk = StatusCode(otlptrace.Status_STATUS_CODE_OK) 17 | StatusCodeError = StatusCode(otlptrace.Status_STATUS_CODE_ERROR) 18 | ) 19 | 20 | // String returns the string representation of the StatusCode. 21 | func (sc StatusCode) String() string { 22 | switch sc { 23 | case StatusCodeUnset: 24 | return "Unset" 25 | case StatusCodeOk: 26 | return "Ok" 27 | case StatusCodeError: 28 | return "Error" 29 | } 30 | return "" 31 | } 32 | -------------------------------------------------------------------------------- /pdata/ptrace/status_code_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package ptrace // import "go.opentelemetry.io/collector/pdata/ptrace" 5 | 6 | import ( 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestStatusCodeString(t *testing.T) { 13 | assert.EqualValues(t, "Unset", StatusCodeUnset.String()) 14 | assert.EqualValues(t, "Ok", StatusCodeOk.String()) 15 | assert.EqualValues(t, "Error", StatusCodeError.String()) 16 | assert.EqualValues(t, "", StatusCode(100).String()) 17 | } 18 | -------------------------------------------------------------------------------- /processor/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /processor/batchprocessor/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /processor/batchprocessor/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | timeout: 10s 2 | send_batch_size: 10000 3 | send_batch_max_size: 11000 4 | -------------------------------------------------------------------------------- /processor/memorylimiterprocessor/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /processor/memorylimiterprocessor/config_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package memorylimiterprocessor 5 | 6 | import ( 7 | "path/filepath" 8 | "testing" 9 | "time" 10 | 11 | "github.com/stretchr/testify/assert" 12 | "github.com/stretchr/testify/require" 13 | 14 | "go.opentelemetry.io/collector/component" 15 | "go.opentelemetry.io/collector/confmap" 16 | "go.opentelemetry.io/collector/confmap/confmaptest" 17 | ) 18 | 19 | func TestUnmarshalDefaultConfig(t *testing.T) { 20 | factory := NewFactory() 21 | cfg := factory.CreateDefaultConfig() 22 | assert.NoError(t, component.UnmarshalConfig(confmap.New(), cfg)) 23 | assert.Equal(t, factory.CreateDefaultConfig(), cfg) 24 | } 25 | 26 | func TestUnmarshalConfig(t *testing.T) { 27 | cm, err := confmaptest.LoadConf(filepath.Join("testdata", "config.yaml")) 28 | require.NoError(t, err) 29 | factory := NewFactory() 30 | cfg := factory.CreateDefaultConfig() 31 | assert.NoError(t, component.UnmarshalConfig(cm, cfg)) 32 | assert.Equal(t, 33 | &Config{ 34 | CheckInterval: 5 * time.Second, 35 | MemoryLimitMiB: 4000, 36 | MemorySpikeLimitMiB: 500, 37 | }, cfg) 38 | } 39 | -------------------------------------------------------------------------------- /processor/memorylimiterprocessor/testdata/config.yaml: -------------------------------------------------------------------------------- 1 | # check_interval is the time between measurements of memory usage for the 2 | # purposes of avoiding going over the limits. Defaults to zero, so no 3 | # checks will be performed. Values below 1 second are not recommended since 4 | # it can result in unnecessary CPU consumption. 5 | check_interval: 5s 6 | 7 | # Maximum amount of memory, in MiB, targeted to be allocated by the process heap. 8 | # Note that typically the total memory usage of process will be about 50MiB higher 9 | # than this value. 10 | limit_mib: 4000 11 | 12 | # The maximum, in MiB, spike expected between the measurements of memory usage. 13 | spike_limit_mib: 500 14 | -------------------------------------------------------------------------------- /receiver/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/Makefile: -------------------------------------------------------------------------------- 1 | include ../../Makefile.Common 2 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package otlpreceiver receives data in OTLP format. 5 | package otlpreceiver // import "go.opentelemetry.io/collector/receiver/otlpreceiver" 6 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/arrow_without_grpc.yaml: -------------------------------------------------------------------------------- 1 | # The following entry initializes the an OTLP receiver without gRPC but with arrow. 2 | protocols: 3 | http: 4 | arrow: 5 | disabled: false 6 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/bad_no_proto_config.yaml: -------------------------------------------------------------------------------- 1 | protocols: 2 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/bad_proto_config.yaml: -------------------------------------------------------------------------------- 1 | protocols: 2 | thrift: 3 | endpoint: "127.0.0.1:1234" 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/default.yaml: -------------------------------------------------------------------------------- 1 | # The following entry initializes the default OTLP receiver. 2 | # The full name of this receiver is `otlp` and can be referenced in pipelines by 'otlp'. 3 | protocols: 4 | grpc: 5 | http: 6 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/invalid_logs_path.yaml: -------------------------------------------------------------------------------- 1 | protocols: 2 | http: 3 | logs_url_path: ":invalid" 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/invalid_metrics_path.yaml: -------------------------------------------------------------------------------- 1 | protocols: 2 | http: 3 | metrics_url_path: ":invalid" 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/invalid_traces_path.yaml: -------------------------------------------------------------------------------- 1 | protocols: 2 | http: 3 | traces_url_path: ":invalid" 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/only_grpc.yaml: -------------------------------------------------------------------------------- 1 | # The following entry initializes the default OTLP receiver with only gRPC support. 2 | protocols: 3 | grpc: 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/only_http.yaml: -------------------------------------------------------------------------------- 1 | # The following entry initializes the default OTLP receiver with only http support. 2 | protocols: 3 | http: 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/only_http_empty_map.yaml: -------------------------------------------------------------------------------- 1 | # The following entry initializes the default OTLP receiver with only http support by setting it explicitly to an empty map. 2 | protocols: 3 | http: {} 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/only_http_null.yaml: -------------------------------------------------------------------------------- 1 | # The following entry initializes the default OTLP receiver with only http support by setting it explicitly to null. 2 | protocols: 3 | http: null 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/typo_default_proto_config.yaml: -------------------------------------------------------------------------------- 1 | protocols: 2 | grpc: 3 | htttp: 4 | -------------------------------------------------------------------------------- /receiver/otlpreceiver/testdata/uds.yaml: -------------------------------------------------------------------------------- 1 | # The following entry demonstrates how to specify a Unix Domain Socket for the server. 2 | protocols: 3 | grpc: 4 | transport: unix 5 | endpoint: /tmp/grpc_otlp.sock 6 | http: 7 | # transport: unix 8 | endpoint: /tmp/http_otlp.sock 9 | -------------------------------------------------------------------------------- /receiver/scrapererror/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package scrapererror provides custom error types for scrapers. 5 | package scrapererror // import "go.opentelemetry.io/collector/receiver/scrapererror" 6 | -------------------------------------------------------------------------------- /receiver/scrapererror/partialscrapeerror.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package scrapererror // import "go.opentelemetry.io/collector/receiver/scrapererror" 5 | 6 | import "errors" 7 | 8 | // PartialScrapeError is an error to represent 9 | // that a subset of metrics were failed to be scraped. 10 | type PartialScrapeError struct { 11 | error 12 | Failed int 13 | } 14 | 15 | // NewPartialScrapeError creates PartialScrapeError for failed metrics. 16 | // Use this error type only when a subset of data was failed to be scraped. 17 | func NewPartialScrapeError(err error, failed int) PartialScrapeError { 18 | return PartialScrapeError{ 19 | error: err, 20 | Failed: failed, 21 | } 22 | } 23 | 24 | // IsPartialScrapeError checks if an error was wrapped with PartialScrapeError. 25 | func IsPartialScrapeError(err error) bool { 26 | if err == nil { 27 | return false 28 | } 29 | 30 | var partialScrapeErr PartialScrapeError 31 | return errors.As(err, &partialScrapeErr) 32 | } 33 | -------------------------------------------------------------------------------- /receiver/scrapererror/partialscrapeerror_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package scrapererror 5 | 6 | import ( 7 | "errors" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | "github.com/stretchr/testify/require" 12 | ) 13 | 14 | func TestPartialScrapeError(t *testing.T) { 15 | failed := 2 16 | err := errors.New("some error") 17 | partialErr := NewPartialScrapeError(err, failed) 18 | assert.Equal(t, err.Error(), partialErr.Error()) 19 | assert.Equal(t, failed, partialErr.Failed) 20 | } 21 | 22 | func TestIsPartialScrapeError(t *testing.T) { 23 | err := errors.New("testError") 24 | require.False(t, IsPartialScrapeError(err)) 25 | 26 | err = NewPartialScrapeError(err, 2) 27 | require.True(t, IsPartialScrapeError(err)) 28 | } 29 | -------------------------------------------------------------------------------- /receiver/scraperhelper/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | // Package scraperhelper provides utilities for scrapers. 5 | package scraperhelper // import "go.opentelemetry.io/collector/receiver/scraperhelper" 6 | -------------------------------------------------------------------------------- /renovate.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://docs.renovatebot.com/renovate-schema.json", 3 | "labels": [ 4 | "dependencies" 5 | ], 6 | "extends": [ 7 | "config:base" 8 | ], 9 | "schedule": ["every tuesday"], 10 | "packageRules": [ 11 | { 12 | "matchManagers": ["dockerfile"], 13 | "groupName": "dockerfile deps" 14 | }, 15 | { 16 | "matchManagers": ["docker-compose"], 17 | "groupName": "docker-compose deps" 18 | }, 19 | { 20 | "matchManagers": ["github-actions"], 21 | "groupName": "github-actions deps" 22 | }, 23 | { 24 | "matchManagers": ["gomod"], 25 | "matchUpdateTypes": ["minor", "major"] 26 | } 27 | ], 28 | "ignoreDeps": [ 29 | "github.com/mattn/go-ieproxy" 30 | ] 31 | } 32 | -------------------------------------------------------------------------------- /semconv/Makefile: -------------------------------------------------------------------------------- 1 | include ../Makefile.Common 2 | -------------------------------------------------------------------------------- /semconv/go.mod: -------------------------------------------------------------------------------- 1 | module go.opentelemetry.io/collector/semconv 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/hashicorp/go-version v1.6.0 7 | github.com/stretchr/testify v1.8.4 8 | ) 9 | 10 | require ( 11 | github.com/davecgh/go-spew v1.1.1 // indirect 12 | github.com/kr/pretty v0.3.1 // indirect 13 | github.com/pmezard/go-difflib v1.0.0 // indirect 14 | github.com/rogpeppe/go-internal v1.10.0 // indirect 15 | gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect 16 | gopkg.in/yaml.v3 v3.0.1 // indirect 17 | ) 18 | 19 | retract ( 20 | v0.76.0 // Depends on retracted pdata v1.0.0-rc10 module, use v0.76.1 21 | v0.69.0 // Release failed, use v0.69.1 22 | v0.57.1 // Release failed, use v0.57.2 23 | v0.57.0 // Release failed, use v0.57.2 24 | ) 25 | -------------------------------------------------------------------------------- /semconv/semconv_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv 5 | 6 | import ( 7 | "os" 8 | "path/filepath" 9 | "testing" 10 | 11 | version "github.com/hashicorp/go-version" 12 | "github.com/stretchr/testify/assert" 13 | ) 14 | 15 | func TestAllSemConvFilesAreCrated(t *testing.T) { 16 | // Files that have to be present in each semconv package 17 | var expectedFiles = []string{"generated_resource.go", "generated_trace.go", "schema.go", "nonstandard.go"} 18 | 19 | files, err := os.ReadDir(".") 20 | assert.NoError(t, err) 21 | 22 | constraints, err := version.NewConstraint("> v1.16.0") 23 | assert.NoError(t, err) 24 | 25 | for _, f := range files { 26 | if !f.IsDir() { 27 | continue 28 | } 29 | 30 | ver, err := version.NewVersion(f.Name()) 31 | assert.NoError(t, err) 32 | 33 | expected := make([]string, len(expectedFiles)) 34 | copy(expected, expectedFiles) 35 | 36 | if constraints.Check(ver) { 37 | expected[len(expected)-1] = "generated_event.go" 38 | } 39 | 40 | for _, ef := range expected { 41 | assert.FileExists(t, filepath.Join(".", f.Name(), ef)) 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /semconv/v1.10.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.10.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.10.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.10.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.10.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.11.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.11.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.11.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.11.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.11.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.12.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.12.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.12.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.12.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.12.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.13.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.13.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.13.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.13.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.13.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.16.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.16.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.16.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.16.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.16.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.17.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.17.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.17.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.18.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.18.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.18.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.5.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.5.0" 5 | 6 | const ( 7 | InstrumentationLibraryName = "otel.library.name" 8 | InstrumentationLibraryVersion = "otel.library.version" 9 | ) 10 | 11 | const ( 12 | OtelStatusCode = "otel.status_code" 13 | OtelStatusDescription = "otel.status_description" 14 | ) 15 | -------------------------------------------------------------------------------- /semconv/v1.5.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.5.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.5.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.6.1/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.6.1" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.6.1/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.6.1" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.6.1" 10 | -------------------------------------------------------------------------------- /semconv/v1.7.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.7.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.7.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.7.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.7.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.8.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.8.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.8.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.8.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.8.0" 10 | -------------------------------------------------------------------------------- /semconv/v1.9.0/nonstandard.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.9.0" 5 | 6 | const ( 7 | OtelLibraryName = "otel.library.name" 8 | OtelLibraryVersion = "otel.library.version" 9 | OtelStatusCode = "otel.status_code" 10 | OtelStatusDescription = "otel.status_description" 11 | ) 12 | -------------------------------------------------------------------------------- /semconv/v1.9.0/schema.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package semconv // import "go.opentelemetry.io/collector/semconv/v1.9.0" 5 | 6 | // SchemaURL is the schema URL that matches the version of the semantic conventions 7 | // that this package defines. Conventions packages starting from v1.4.0 must declare 8 | // non-empty schema URL in the form https://opentelemetry.io/schemas/ 9 | const SchemaURL = "https://opentelemetry.io/schemas/1.9.0" 10 | -------------------------------------------------------------------------------- /service/extensions/config.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package extensions // import "go.opentelemetry.io/collector/service/extensions" 5 | 6 | import "go.opentelemetry.io/collector/component" 7 | 8 | // Config represents the ordered list of extensions configured for the service. 9 | type Config []component.ID 10 | -------------------------------------------------------------------------------- /service/internal/components/components.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package components // import "go.opentelemetry.io/collector/service/internal/components" 5 | 6 | import ( 7 | "go.uber.org/zap" 8 | 9 | "go.opentelemetry.io/collector/component" 10 | ) 11 | 12 | // LogStabilityLevel logs the stability level of a component. The log level is set to info for 13 | // undefined, unmaintained, deprecated and development. The log level is set to debug 14 | // for alpha, beta and stable. 15 | func LogStabilityLevel(logger *zap.Logger, sl component.StabilityLevel) { 16 | if sl >= component.StabilityLevelAlpha { 17 | logger.Debug(sl.LogMessage(), zap.String(zapStabilityKey, sl.String())) 18 | } else { 19 | logger.Info(sl.LogMessage(), zap.String(zapStabilityKey, sl.String())) 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /service/internal/components/host_wrapper_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package components 5 | 6 | import ( 7 | "errors" 8 | "testing" 9 | 10 | "go.uber.org/zap" 11 | 12 | "go.opentelemetry.io/collector/component/componenttest" 13 | ) 14 | 15 | func Test_newHostWrapper(_ *testing.T) { 16 | hw := NewHostWrapper(componenttest.NewNopHost(), zap.NewNop()) 17 | hw.ReportFatalError(errors.New("test error")) 18 | } 19 | -------------------------------------------------------------------------------- /service/internal/testcomponents/example_connector_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package testcomponents 5 | 6 | import ( 7 | "context" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | 12 | "go.opentelemetry.io/collector/component/componenttest" 13 | ) 14 | 15 | func TestExampleConnector(t *testing.T) { 16 | conn := &ExampleConnector{} 17 | host := componenttest.NewNopHost() 18 | assert.False(t, conn.Started()) 19 | assert.NoError(t, conn.Start(context.Background(), host)) 20 | assert.True(t, conn.Started()) 21 | 22 | assert.False(t, conn.Stopped()) 23 | assert.NoError(t, conn.Shutdown(context.Background())) 24 | assert.True(t, conn.Stopped()) 25 | } 26 | -------------------------------------------------------------------------------- /service/internal/testcomponents/example_processor_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package testcomponents 5 | 6 | import ( 7 | "context" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | 12 | "go.opentelemetry.io/collector/component/componenttest" 13 | ) 14 | 15 | func TestExampleProcessor(t *testing.T) { 16 | prc := &ExampleProcessor{} 17 | host := componenttest.NewNopHost() 18 | assert.False(t, prc.Started()) 19 | assert.NoError(t, prc.Start(context.Background(), host)) 20 | assert.True(t, prc.Started()) 21 | 22 | assert.False(t, prc.Stopped()) 23 | assert.NoError(t, prc.Shutdown(context.Background())) 24 | assert.True(t, prc.Stopped()) 25 | } 26 | -------------------------------------------------------------------------------- /service/internal/testcomponents/example_receiver_test.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package testcomponents 5 | 6 | import ( 7 | "context" 8 | "testing" 9 | 10 | "github.com/stretchr/testify/assert" 11 | 12 | "go.opentelemetry.io/collector/component/componenttest" 13 | ) 14 | 15 | func TestExampleReceiver(t *testing.T) { 16 | rcv := &ExampleReceiver{} 17 | host := componenttest.NewNopHost() 18 | assert.False(t, rcv.Started()) 19 | assert.NoError(t, rcv.Start(context.Background(), host)) 20 | assert.True(t, rcv.Started()) 21 | 22 | assert.False(t, rcv.Stopped()) 23 | assert.NoError(t, rcv.Shutdown(context.Background())) 24 | assert.True(t, rcv.Stopped()) 25 | } 26 | -------------------------------------------------------------------------------- /service/internal/testcomponents/stateful_component.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package testcomponents // import "go.opentelemetry.io/collector/service/internal/testcomponents" 5 | 6 | import ( 7 | "context" 8 | 9 | "go.opentelemetry.io/collector/component" 10 | ) 11 | 12 | type componentState struct { 13 | started bool 14 | stopped bool 15 | } 16 | 17 | func (cs *componentState) Started() bool { 18 | return cs.started 19 | } 20 | 21 | func (cs *componentState) Stopped() bool { 22 | return cs.stopped 23 | } 24 | 25 | func (cs *componentState) Start(_ context.Context, _ component.Host) error { 26 | cs.started = true 27 | return nil 28 | } 29 | 30 | func (cs *componentState) Shutdown(_ context.Context) error { 31 | cs.stopped = true 32 | return nil 33 | } 34 | -------------------------------------------------------------------------------- /service/internal/zpages/templates/component_header.html: -------------------------------------------------------------------------------- 1 | {{$link := .Link}} 2 | {{- if $link -}} 3 |
{{.Name}}
4 | {{- else -}} 5 |
{{.Name}}
6 | {{- end -}} -------------------------------------------------------------------------------- /service/internal/zpages/templates/extensions_table.html: -------------------------------------------------------------------------------- 1 | 2 | {{range $rowindex, $row := .Rows}} 3 | {{- if even $rowindex}} 4 | 5 | {{else}} 6 | {{end -}} 7 | 8 | 9 | {{end}} 10 |
{{.FullName}}
-------------------------------------------------------------------------------- /service/internal/zpages/templates/page_footer.html: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /service/internal/zpages/templates/page_header.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | {{.Title}} 5 | 6 | 7 | 8 | 9 | 10 | 11 |

{{.Title}}

-------------------------------------------------------------------------------- /service/internal/zpages/templates/properties_table.html: -------------------------------------------------------------------------------- 1 | {{.Name}}: 2 | 3 | {{ $index := 0 }} 4 | {{range $index, $element := .Properties}} 5 | {{- if even $index}} 6 | 7 | {{else}} 8 | {{end -}} 9 | 10 | 11 | 12 | 13 | {{end}} 14 |
{{$element|getKey}}  |  {{$element|getValue}}
-------------------------------------------------------------------------------- /service/telemetry/otel_trace_sampler.go: -------------------------------------------------------------------------------- 1 | // Copyright The OpenTelemetry Authors 2 | // SPDX-License-Identifier: Apache-2.0 3 | 4 | package telemetry // import "go.opentelemetry.io/collector/service/telemetry" 5 | 6 | import ( 7 | sdktrace "go.opentelemetry.io/otel/sdk/trace" 8 | ) 9 | 10 | type recordSampler struct{} 11 | 12 | func (r recordSampler) ShouldSample(_ sdktrace.SamplingParameters) sdktrace.SamplingResult { 13 | return sdktrace.SamplingResult{Decision: sdktrace.RecordOnly} 14 | } 15 | 16 | func (r recordSampler) Description() string { 17 | return "Always record sampler" 18 | } 19 | 20 | func alwaysRecord() sdktrace.Sampler { 21 | rs := &recordSampler{} 22 | return sdktrace.ParentBased( 23 | rs, 24 | sdktrace.WithRemoteParentSampled(sdktrace.AlwaysSample()), 25 | sdktrace.WithRemoteParentNotSampled(rs), 26 | sdktrace.WithLocalParentSampled(sdktrace.AlwaysSample()), 27 | sdktrace.WithRemoteParentSampled(rs)) 28 | } 29 | --------------------------------------------------------------------------------