131 lines
5.0 KiB
Go
131 lines
5.0 KiB
Go
// Copyright The OpenTelemetry Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package component // import "go.opentelemetry.io/collector/component"
|
|
|
|
import (
|
|
"context"
|
|
|
|
"go.opentelemetry.io/collector/confmap"
|
|
)
|
|
|
|
// ExtensionConfig is the configuration of a component.Extension. Specific extensions must implement
|
|
// this interface and must embed config.ExtensionSettings struct or a struct that extends it.
|
|
type ExtensionConfig interface {
|
|
identifiable
|
|
validatable
|
|
|
|
privateConfigExtension()
|
|
}
|
|
|
|
// UnmarshalExtensionConfig helper function to unmarshal an ExtensionConfig.
|
|
// It checks if the config implements confmap.Unmarshaler and uses that if available,
|
|
// otherwise uses Map.UnmarshalExact, erroring if a field is nonexistent.
|
|
func UnmarshalExtensionConfig(conf *confmap.Conf, cfg ExtensionConfig) error {
|
|
return unmarshal(conf, cfg)
|
|
}
|
|
|
|
// Extension is the interface for objects hosted by the OpenTelemetry Collector that
|
|
// don't participate directly on data pipelines but provide some functionality
|
|
// to the service, examples: health check endpoint, z-pages, etc.
|
|
type Extension interface {
|
|
Component
|
|
}
|
|
|
|
// PipelineWatcher is an extra interface for Extension hosted by the OpenTelemetry
|
|
// Collector that is to be implemented by extensions interested in changes to pipeline
|
|
// states. Typically this will be used by extensions that change their behavior if data is
|
|
// being ingested or not, e.g.: a k8s readiness probe.
|
|
type PipelineWatcher interface {
|
|
// Ready notifies the Extension that all pipelines were built and the
|
|
// receivers were started, i.e.: the service is ready to receive data
|
|
// (note that it may already have received data when this method is called).
|
|
Ready() error
|
|
|
|
// NotReady notifies the Extension that all receivers are about to be stopped,
|
|
// i.e.: pipeline receivers will not accept new data.
|
|
// This is sent before receivers are stopped, so the Extension can take any
|
|
// appropriate actions before that happens.
|
|
NotReady() error
|
|
}
|
|
|
|
// ExtensionCreateSettings is passed to ExtensionFactory.Create* functions.
|
|
type ExtensionCreateSettings struct {
|
|
TelemetrySettings
|
|
|
|
// BuildInfo can be used by components for informational purposes
|
|
BuildInfo BuildInfo
|
|
}
|
|
|
|
// ExtensionCreateDefaultConfigFunc is the equivalent of ExtensionFactory.CreateDefaultConfig()
|
|
type ExtensionCreateDefaultConfigFunc func() ExtensionConfig
|
|
|
|
// CreateDefaultConfig implements ExtensionFactory.CreateDefaultConfig()
|
|
func (f ExtensionCreateDefaultConfigFunc) CreateDefaultConfig() ExtensionConfig {
|
|
return f()
|
|
}
|
|
|
|
// CreateExtensionFunc is the equivalent of ExtensionFactory.CreateExtension()
|
|
type CreateExtensionFunc func(context.Context, ExtensionCreateSettings, ExtensionConfig) (Extension, error)
|
|
|
|
// CreateExtension implements ExtensionFactory.CreateExtension.
|
|
func (f CreateExtensionFunc) CreateExtension(ctx context.Context, set ExtensionCreateSettings, cfg ExtensionConfig) (Extension, error) {
|
|
return f(ctx, set, cfg)
|
|
}
|
|
|
|
// ExtensionFactory is a factory for extensions to the service.
|
|
type ExtensionFactory interface {
|
|
Factory
|
|
|
|
// CreateDefaultConfig creates the default configuration for the Extension.
|
|
// This method can be called multiple times depending on the pipeline
|
|
// configuration and should not cause side-effects that prevent the creation
|
|
// of multiple instances of the Extension.
|
|
// The object returned by this method needs to pass the checks implemented by
|
|
// 'componenttest.CheckConfigStruct'. It is recommended to have these checks in the
|
|
// tests of any implementation of the Factory interface.
|
|
CreateDefaultConfig() ExtensionConfig
|
|
|
|
// CreateExtension creates an extension based on the given config.
|
|
CreateExtension(ctx context.Context, set ExtensionCreateSettings, cfg ExtensionConfig) (Extension, error)
|
|
|
|
// ExtensionStability gets the stability level of the Extension.
|
|
ExtensionStability() StabilityLevel
|
|
}
|
|
|
|
type extensionFactory struct {
|
|
baseFactory
|
|
ExtensionCreateDefaultConfigFunc
|
|
CreateExtensionFunc
|
|
extensionStability StabilityLevel
|
|
}
|
|
|
|
func (ef *extensionFactory) ExtensionStability() StabilityLevel {
|
|
return ef.extensionStability
|
|
}
|
|
|
|
// NewExtensionFactory returns a new ExtensionFactory based on this configuration.
|
|
func NewExtensionFactory(
|
|
cfgType Type,
|
|
createDefaultConfig ExtensionCreateDefaultConfigFunc,
|
|
createServiceExtension CreateExtensionFunc,
|
|
sl StabilityLevel) ExtensionFactory {
|
|
return &extensionFactory{
|
|
baseFactory: baseFactory{cfgType: cfgType},
|
|
ExtensionCreateDefaultConfigFunc: createDefaultConfig,
|
|
CreateExtensionFunc: createServiceExtension,
|
|
extensionStability: sl,
|
|
}
|
|
}
|