// New returns a new Winlogbeat.
func New(b *beat.Beat, _ *common.Config) (beat.Beater, error) {
// Read configuration.
// XXX: winlogbeat validates top-level config -> ignore beater config and
// parse complete top-level config
config := config.DefaultSettings
rawConfig := b.RawConfig
err := rawConfig.Unpack(&config)
if err != nil {
return nil, fmt.Errorf("Error reading configuration file. %v", err)
}
// reslove registry file path
config.Winlogbeat.RegistryFile = paths.Resolve(
paths.Data, config.Winlogbeat.RegistryFile)
logp.Info("State will be read from and persisted to %s",
config.Winlogbeat.RegistryFile)
eb := &Winlogbeat{
beat: b,
config: &config,
done: make(chan struct{}),
}
if err := eb.init(b); err != nil {
return nil, err
}
return eb, nil
}
func (r *Registrar) Init() error {
// Init state
r.state = map[string]*FileState{}
r.Channel = make(chan []*FileEvent, 1)
// Set to default in case it is not set
if r.registryFile == "" {
r.registryFile = cfg.DefaultRegistryFile
}
// The registry file is opened in the data path
r.registryFile = paths.Resolve(paths.Data, r.registryFile)
// Create directory if it does not already exist.
registryPath := filepath.Dir(r.registryFile)
err := os.MkdirAll(registryPath, 0755)
if err != nil {
return fmt.Errorf("Failed to created registry file dir %s: %v",
registryPath, err)
}
logp.Info("Registry file set to: %s", r.registryFile)
return nil
}
// Fetches and merges all config files given by configDir. All are put into one config object
func (config *Config) FetchConfigs() {
configDir := config.Filebeat.ConfigDir
// If option not set, do nothing
if configDir == "" {
return
}
// If configDir is relative, consider it relative to the config path
configDir = paths.Resolve(paths.Config, configDir)
// Check if optional configDir is set to fetch additional config files
logp.Info("Additional config files are fetched from: %s", configDir)
configFiles, err := getConfigFiles(configDir)
if err != nil {
log.Fatal("Could not use config_dir of: ", configDir, err)
}
err = mergeConfigFiles(configFiles, config)
if err != nil {
log.Fatal("Error merging config files: ", err)
}
if len(config.Filebeat.Prospectors) == 0 {
log.Fatalf("No paths given. What files do you want me to watch?")
}
}
// readTemplates reads the ES mapping template from the disk, if configured.
func (out *elasticsearchOutput) readTemplate(config *Template) error {
if config.Enabled {
// Set the defaults that depend on the beat name
if config.Name == "" {
config.Name = out.beatName
}
if config.Path == "" {
config.Path = fmt.Sprintf("%s.template.json", out.beatName)
}
if config.Versions.Es2x.Path == "" {
config.Versions.Es2x.Path = fmt.Sprintf("%s.template-es2x.json", out.beatName)
}
// Look for the template in the configuration path, if it's not absolute
templatePath := paths.Resolve(paths.Config, config.Path)
logp.Info("Loading template enabled. Reading template file: %v", templatePath)
template, err := readTemplate(templatePath)
if err != nil {
return fmt.Errorf("Error loading template %s: %v", templatePath, err)
}
out.template = template
if config.Versions.Es2x.Enabled {
// Read the version of the template compatible with ES 2.x
templatePath := paths.Resolve(paths.Config, config.Versions.Es2x.Path)
logp.Info("Loading template enabled for Elasticsearch 2.x. Reading template file: %v", templatePath)
template, err := readTemplate(templatePath)
if err != nil {
return fmt.Errorf("Error loading template %s: %v", templatePath, err)
}
out.template2x = template
}
}
return nil
}
// readTemplates reads the ES mapping template from the disk, if configured.
func (out *elasticsearchOutput) readTemplate(config Template) error {
if len(config.Name) > 0 {
// Look for the template in the configuration path, if it's not absolute
templatePath := paths.Resolve(paths.Config, config.Path)
logp.Info("Loading template enabled. Reading template file: %v", templatePath)
var err error
out.templateContents, err = ioutil.ReadFile(templatePath)
if err != nil {
return fmt.Errorf("Error loading template %s: %v", templatePath, err)
}
}
return nil
}
// Init sets up the Registrar and make sure the registry file is setup correctly
func (r *Registrar) Init() error {
// The registry file is opened in the data path
r.registryFile = paths.Resolve(paths.Data, r.registryFile)
// Create directory if it does not already exist.
registryPath := filepath.Dir(r.registryFile)
err := os.MkdirAll(registryPath, 0755)
if err != nil {
return fmt.Errorf("Failed to created registry file dir %s: %v",
registryPath, err)
}
logp.Info("Registry file set to: %s", r.registryFile)
return nil
}
// Init sets up the Registrar and make sure the registry file is setup correctly
func (r *Registrar) Init() error {
// The registry file is opened in the data path
r.registryFile = paths.Resolve(paths.Data, r.registryFile)
// Create directory if it does not already exist.
registryPath := filepath.Dir(r.registryFile)
err := os.MkdirAll(registryPath, 0755)
if err != nil {
return fmt.Errorf("Failed to created registry file dir %s: %v", registryPath, err)
}
// Check if files exists
fileInfo, err := os.Lstat(r.registryFile)
if os.IsNotExist(err) {
logp.Info("No registry file found under: %s. Creating a new registry file.", r.registryFile)
// No registry exists yet, write empty state to check if registry can be written
return r.writeRegistry()
}
if err != nil {
return err
}
// Check if regular file, no dir, no symlink
if !fileInfo.Mode().IsRegular() {
// Special error message for directory
if fileInfo.IsDir() {
return fmt.Errorf("Registry file path must be a file. %s is a directory.", r.registryFile)
}
return fmt.Errorf("Registry file path is not a regular file: %s", r.registryFile)
}
logp.Info("Registry file set to: %s", r.registryFile)
return nil
}
// Config sets up the necessary configuration to use the winlogbeat
func (eb *Winlogbeat) Config(b *beat.Beat) error {
// Read configuration.
err := b.RawConfig.Unpack(&eb.config)
if err != nil {
return fmt.Errorf("Error reading configuration file. %v", err)
}
// Validate configuration.
err = eb.config.Validate()
if err != nil {
return fmt.Errorf("Error validating configuration file. %v", err)
}
debugf("Configuration validated. config=%v", eb.config)
// Registry file grooming.
if eb.config.Winlogbeat.RegistryFile == "" {
eb.config.Winlogbeat.RegistryFile = config.DefaultRegistryFile
}
eb.config.Winlogbeat.RegistryFile = paths.Resolve(paths.Data, eb.config.Winlogbeat.RegistryFile)
logp.Info("State will be read from and persisted to %s",
eb.config.Winlogbeat.RegistryFile)
return nil
}
// Init combines the configuration from config with the command line
// flags to initialize the Logging systems. After calling this function,
// standard output is always enabled. You can make it respect the command
// line flag with a later SetStderr call.
func Init(name string, config *Logging) error {
logLevel, err := getLogLevel(config)
if err != nil {
return err
}
if *verbose {
if LOG_INFO > logLevel {
logLevel = LOG_INFO
}
}
debugSelectors := config.Selectors
if logLevel == LOG_DEBUG {
if len(debugSelectors) == 0 {
debugSelectors = []string{"*"}
}
}
if len(*debugSelectorsStr) > 0 {
debugSelectors = strings.Split(*debugSelectorsStr, ",")
logLevel = LOG_DEBUG
}
// default log location is in the logs path
defaultFilePath := paths.Resolve(paths.Logs, "")
var toSyslog, toFiles bool
if config.ToSyslog != nil {
toSyslog = *config.ToSyslog
} else {
toSyslog = false
}
if config.ToFiles != nil {
toFiles = *config.ToFiles
} else {
toFiles = true
}
// toStderr disables logging to syslog/files
if *toStderr {
toSyslog = false
toFiles = false
}
LogInit(Priority(logLevel), "", toSyslog, true, debugSelectors)
if len(debugSelectors) > 0 {
config.Selectors = debugSelectors
}
if toFiles {
if config.Files == nil {
config.Files = &FileRotator{
Path: defaultFilePath,
Name: name,
}
} else {
if config.Files.Path == "" {
config.Files.Path = defaultFilePath
}
if config.Files.Name == "" {
config.Files.Name = name
}
}
err := SetToFile(true, config.Files)
if err != nil {
return err
}
}
if IsDebug("stdlog") {
// disable standard logging by default (this is sometimes
// used by libraries and we don't want their logs to spam ours)
log.SetOutput(ioutil.Discard)
}
go logExpvars(&config.Metrics)
return nil
}