11468626730

Committed 22 Oct 2024 09:13PM UTC coverage: 72.76% (+0.02%) from 72.738%

Build # 11468626730

Build Type

push

github

Committed by

web-flow

Commit Message

[8.x](backport #2628) Increase azure fetcher timeout (#2630)

Increase azure fetcher timeout (#2628)

* increase azure fetcher timeout

* add function

(cherry picked from commit b24534b35)

Co-authored-by: Kostas Stamatakis <moukoublen@gmail.com>

Run Details

9 of 10 new or added lines in 1 file covered. (90.0%)

8275 of 11373 relevant lines covered (72.76%)

16.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.47

/internal/flavors/benchmark/azure.go

// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you 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 benchmark

import (
        "context"
        "errors"
        "fmt"
        "math"
        "time"

        "github.com/elastic/elastic-agent-libs/logp"

        "github.com/elastic/cloudbeat/internal/config"
        "github.com/elastic/cloudbeat/internal/dataprovider"
        "github.com/elastic/cloudbeat/internal/dataprovider/providers/cloud"
        "github.com/elastic/cloudbeat/internal/flavors/benchmark/builder"
        "github.com/elastic/cloudbeat/internal/resources/fetching"
        "github.com/elastic/cloudbeat/internal/resources/fetching/preset"
        "github.com/elastic/cloudbeat/internal/resources/fetching/registry"
        "github.com/elastic/cloudbeat/internal/resources/providers/azurelib"
        "github.com/elastic/cloudbeat/internal/resources/providers/azurelib/auth"
)

type Azure struct {
        cfgProvider         auth.ConfigProviderAPI
        providerInitializer azurelib.ProviderInitializerAPI
}

func (a *Azure) NewBenchmark(ctx context.Context, log *logp.Logger, cfg *config.Config) (builder.Benchmark, error) {
        resourceCh := make(chan fetching.ResourceInfo, resourceChBufferSize)
        reg, bdp, _, err := a.initialize(ctx, log, cfg, resourceCh)
        if err != nil {
                return nil, err
        }

        return builder.New(
                builder.WithBenchmarkDataProvider(bdp),
                builder.WithManagerTimeout(calculateFetcherTimeout(cfg.Period)),
        ).Build(ctx, log, cfg, resourceCh, reg)
}

//revive:disable-next-line:function-result-limit
func (a *Azure) initialize(_ context.Context, log *logp.Logger, cfg *config.Config, ch chan fetching.ResourceInfo) (registry.Registry, dataprovider.CommonDataProvider, dataprovider.IdProvider, error) {
        if err := a.checkDependencies(); err != nil {
                return nil, nil, nil, err
        }

        azureConfig, err := a.cfgProvider.GetAzureClientConfig(cfg.CloudConfig.Azure)
        if err != nil {
                return nil, nil, nil, fmt.Errorf("failed to initialize azure config: %w", err)
        }

        provider, err := a.providerInitializer.Init(log, *azureConfig)
        if err != nil {
                return nil, nil, nil, fmt.Errorf("failed to initialize azure asset inventory: %v", err)
        }

        fetchers, err := preset.NewCisAzureFactory(log, ch, provider)
        if err != nil {
                return nil, nil, nil, fmt.Errorf("failed to initialize azure fetchers: %v", err)
        }

        return registry.NewRegistry(log, registry.WithFetchersMap(fetchers)),
                cloud.NewDataProvider(
                        cloud.WithAccount(cloud.Identity{
                                Provider: "azure",
                        }),
                ),
                nil,
                nil
}

func (a *Azure) checkDependencies() error {
        if a.cfgProvider == nil {
                return errors.New("azure config provider is uninitialized")
        }

        if a.providerInitializer == nil {
                return errors.New("azure asset inventory is uninitialized")
        }
        return nil
}

// calculateFetcherTimeout calculates the timeout for each fetcher based on period as ~70% of the period duration. If less than 3 hours, it returns 3 hours.
func calculateFetcherTimeout(period time.Duration) time.Duration {
        roundedHours := math.Round(period.Hours() * 0.7)
        to := time.Duration(roundedHours) * time.Hour

        const min = 3 * time.Hour
        if to < min {
                return min
        }

        return to
}

1	// Licensed to Elasticsearch B.V. under one or more contributor
2	// license agreements. See the NOTICE file distributed with
3	// this work for additional information regarding copyright
4	// ownership. Elasticsearch B.V. licenses this file to you under
5	// the Apache License, Version 2.0 (the "License"); you may
6	// not use this file except in compliance with the License.
7	// You may obtain a copy of the License at
8	//
9	// http://www.apache.org/licenses/LICENSE-2.0
10	//
11	// Unless required by applicable law or agreed to in writing,
12	// software distributed under the License is distributed on an
13	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14	// KIND, either express or implied. See the License for the
15	// specific language governing permissions and limitations
16	// under the License.
17
18	package benchmark
19
20	import (
21	"context"
22	"errors"
23	"fmt"
24	"math"
25	"time"
26
27	"github.com/elastic/elastic-agent-libs/logp"
28
29	"github.com/elastic/cloudbeat/internal/config"
30	"github.com/elastic/cloudbeat/internal/dataprovider"
31	"github.com/elastic/cloudbeat/internal/dataprovider/providers/cloud"
32	"github.com/elastic/cloudbeat/internal/flavors/benchmark/builder"
33	"github.com/elastic/cloudbeat/internal/resources/fetching"
34	"github.com/elastic/cloudbeat/internal/resources/fetching/preset"
35	"github.com/elastic/cloudbeat/internal/resources/fetching/registry"
36	"github.com/elastic/cloudbeat/internal/resources/providers/azurelib"
37	"github.com/elastic/cloudbeat/internal/resources/providers/azurelib/auth"
38	)
39
40	type Azure struct {
41	cfgProvider auth.ConfigProviderAPI
42	providerInitializer azurelib.ProviderInitializerAPI
43	}
44
45	func (a Azure) NewBenchmark(ctx context.Context, log logp.Logger, cfg *config.Config) (builder.Benchmark, error) {	×
46	resourceCh := make(chan fetching.ResourceInfo, resourceChBufferSize)	×
47	reg, bdp, _, err := a.initialize(ctx, log, cfg, resourceCh)	×
48	if err != nil {	×
49	return nil, err	×
50	}	×
51
52	return builder.New(	×
53	builder.WithBenchmarkDataProvider(bdp),	×
NEW 54	builder.WithManagerTimeout(calculateFetcherTimeout(cfg.Period)),	×
55	).Build(ctx, log, cfg, resourceCh, reg)	×
56	}
57
58	//revive:disable-next-line:function-result-limit
59	func (a Azure) initialize(_ context.Context, log logp.Logger, cfg *config.Config, ch chan fetching.ResourceInfo) (registry.Registry, dataprovider.CommonDataProvider, dataprovider.IdProvider, error) {	5✔
60	if err := a.checkDependencies(); err != nil {	7✔
61	return nil, nil, nil, err	2✔
62	}	2✔
63
64	azureConfig, err := a.cfgProvider.GetAzureClientConfig(cfg.CloudConfig.Azure)	3✔
65	if err != nil {	4✔
66	return nil, nil, nil, fmt.Errorf("failed to initialize azure config: %w", err)	1✔
67	}	1✔
68
69	provider, err := a.providerInitializer.Init(log, *azureConfig)	2✔
70	if err != nil {	3✔
71	return nil, nil, nil, fmt.Errorf("failed to initialize azure asset inventory: %v", err)	1✔
72	}	1✔
73
74	fetchers, err := preset.NewCisAzureFactory(log, ch, provider)	1✔
75	if err != nil {	1✔
76	return nil, nil, nil, fmt.Errorf("failed to initialize azure fetchers: %v", err)	×
77	}	×
78
79	return registry.NewRegistry(log, registry.WithFetchersMap(fetchers)),	1✔
80	cloud.NewDataProvider(	1✔
81	cloud.WithAccount(cloud.Identity{	1✔
82	Provider: "azure",	1✔
83	}),	1✔
84	),	1✔
85	nil,	1✔
86	nil	1✔
87	}
88
89	func (a *Azure) checkDependencies() error {	5✔
90	if a.cfgProvider == nil {	6✔
91	return errors.New("azure config provider is uninitialized")	1✔
92	}	1✔
93
94	if a.providerInitializer == nil {	5✔
95	return errors.New("azure asset inventory is uninitialized")	1✔
96	}	1✔
97	return nil	3✔
98	}
99
100	// calculateFetcherTimeout calculates the timeout for each fetcher based on period as ~70% of the period duration. If less than 3 hours, it returns 3 hours.
101	func calculateFetcherTimeout(period time.Duration) time.Duration {	7✔
102	roundedHours := math.Round(period.Hours() * 0.7)	7✔
103	to := time.Duration(roundedHours) * time.Hour	7✔
104		7✔
105	const min = 3 * time.Hour	7✔
106	if to < min {	12✔
107	return min	5✔
108	}	5✔
109
110	return to	2✔
111	}

elastic / cloudbeat / 11468626730

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous