Debian Codegraph @

pkg/server/options/audit.go

raw
1 /*
2 Copyright 2017 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package options
18
19 import (
20 "fmt"
21 "io"
22 "os"
23 "path/filepath"
24 "strings"
25 "time"
26
27 "github.com/spf13/pflag"
28 "gopkg.in/natefinch/lumberjack.v2"
29 "k8s.io/klog/v2"
30
31 "k8s.io/apimachinery/pkg/runtime/schema"
32 utilnet "k8s.io/apimachinery/pkg/util/net"
33 "k8s.io/apimachinery/pkg/util/sets"
34 auditinternal "k8s.io/apiserver/pkg/apis/audit"
35 auditv1 "k8s.io/apiserver/pkg/apis/audit/v1"
36 "k8s.io/apiserver/pkg/audit"
37 "k8s.io/apiserver/pkg/audit/policy"
38 "k8s.io/apiserver/pkg/server"
39 "k8s.io/apiserver/pkg/server/egressselector"
40 "k8s.io/apiserver/pkg/util/webhook"
41 pluginbuffered "k8s.io/apiserver/plugin/pkg/audit/buffered"
42 pluginlog "k8s.io/apiserver/plugin/pkg/audit/log"
43 plugintruncate "k8s.io/apiserver/plugin/pkg/audit/truncate"
44 pluginwebhook "k8s.io/apiserver/plugin/pkg/audit/webhook"
45 )
46
47 const (
48 // Default configuration values for ModeBatch.
49 defaultBatchBufferSize = 10000 // Buffer up to 10000 events before starting discarding.
50 // These batch parameters are only used by the webhook backend.
51 defaultBatchMaxSize = 400 // Only send up to 400 events at a time.
52 defaultBatchMaxWait = 30 * time.Second // Send events at least twice a minute.
53 defaultBatchThrottleQPS = 10 // Limit the send rate by 10 QPS.
54 defaultBatchThrottleBurst = 15 // Allow up to 15 QPS burst.
55 )
56
57 func appendBackend(existing, newBackend audit.Backend) audit.Backend {
58 if existing == nil {
59 return newBackend
60 }
61 if newBackend == nil {
62 return existing
63 }
64 return audit.Union(existing, newBackend)
65 }
66
67 type AuditOptions struct {
68 // Policy configuration file for filtering audit events that are captured.
69 // If unspecified, a default is provided.
70 PolicyFile string
71
72 // Plugin options
73 LogOptions AuditLogOptions
74 WebhookOptions AuditWebhookOptions
75 }
76
77 const (
78 // ModeBatch indicates that the audit backend should buffer audit events
79 // internally, sending batch updates either once a certain number of
80 // events have been received or a certain amount of time has passed.
81 ModeBatch = "batch"
82 // ModeBlocking causes the audit backend to block on every attempt to process
83 // a set of events. This causes requests to the API server to wait for the
84 // flush before sending a response.
85 ModeBlocking = "blocking"
86 // ModeBlockingStrict is the same as ModeBlocking, except when there is
87 // a failure during audit logging at RequestReceived stage, the whole
88 // request to apiserver will fail.
89 ModeBlockingStrict = "blocking-strict"
90 )
91
92 // AllowedModes is the modes known for audit backends.
93 var AllowedModes = []string{
94 ModeBatch,
95 ModeBlocking,
96 ModeBlockingStrict,
97 }
98
99 type AuditBatchOptions struct {
100 // Should the backend asynchronous batch events to the webhook backend or
101 // should the backend block responses?
102 //
103 // Defaults to asynchronous batch events.
104 Mode string
105 // Configuration for batching backend. Only used in batch mode.
106 BatchConfig pluginbuffered.BatchConfig
107 }
108
109 type AuditTruncateOptions struct {
110 // Whether truncating is enabled or not.
111 Enabled bool
112
113 // Truncating configuration.
114 TruncateConfig plugintruncate.Config
115 }
116
117 // AuditLogOptions determines the output of the structured audit log by default.
118 type AuditLogOptions struct {
119 Path string
120 MaxAge int
121 MaxBackups int
122 MaxSize int
123 Format string
124 Compress bool
125
126 BatchOptions AuditBatchOptions
127 TruncateOptions AuditTruncateOptions
128
129 // API group version used for serializing audit events.
130 GroupVersionString string
131 }
132
133 // AuditWebhookOptions control the webhook configuration for audit events.
134 type AuditWebhookOptions struct {
135 ConfigFile string
136 InitialBackoff time.Duration
137
138 BatchOptions AuditBatchOptions
139 TruncateOptions AuditTruncateOptions
140
141 // API group version used for serializing audit events.
142 GroupVersionString string
143 }
144
145 func NewAuditOptions() *AuditOptions {
146 return &AuditOptions{
147 WebhookOptions: AuditWebhookOptions{
148 InitialBackoff: pluginwebhook.DefaultInitialBackoffDelay,
149 BatchOptions: AuditBatchOptions{
150 Mode: ModeBatch,
151 BatchConfig: defaultWebhookBatchConfig(),
152 },
153 TruncateOptions: NewAuditTruncateOptions(),
154 GroupVersionString: "audit.k8s.io/v1",
155 },
156 LogOptions: AuditLogOptions{
157 Format: pluginlog.FormatJson,
158 BatchOptions: AuditBatchOptions{
159 Mode: ModeBlocking,
160 BatchConfig: defaultLogBatchConfig(),
161 },
162 TruncateOptions: NewAuditTruncateOptions(),
163 GroupVersionString: "audit.k8s.io/v1",
164 },
165 }
166 }
167
168 func NewAuditTruncateOptions() AuditTruncateOptions {
169 return AuditTruncateOptions{
170 Enabled: false,
171 TruncateConfig: plugintruncate.Config{
172 MaxBatchSize: 10 * 1024 * 1024, // 10MB
173 MaxEventSize: 100 * 1024, // 100KB
174 },
175 }
176 }
177
178 // Validate checks invalid config combination
179 func (o *AuditOptions) Validate() []error {
180 if o == nil {
181 return nil
182 }
183
184 var allErrors []error
185 allErrors = append(allErrors, o.LogOptions.Validate()...)
186 allErrors = append(allErrors, o.WebhookOptions.Validate()...)
187
188 return allErrors
189 }
190
191 func validateBackendMode(pluginName string, mode string) error {
192 for _, m := range AllowedModes {
193 if m == mode {
194 return nil
195 }
196 }
197 return fmt.Errorf("invalid audit %s mode %s, allowed modes are %q", pluginName, mode, strings.Join(AllowedModes, ","))
198 }
199
200 func validateBackendBatchOptions(pluginName string, options AuditBatchOptions) error {
201 if err := validateBackendMode(pluginName, options.Mode); err != nil {
202 return err
203 }
204 if options.Mode != ModeBatch {
205 // Don't validate the unused options.
206 return nil
207 }
208 config := options.BatchConfig
209 if config.BufferSize <= 0 {
210 return fmt.Errorf("invalid audit batch %s buffer size %v, must be a positive number", pluginName, config.BufferSize)
211 }
212 if config.MaxBatchSize <= 0 {
213 return fmt.Errorf("invalid audit batch %s max batch size %v, must be a positive number", pluginName, config.MaxBatchSize)
214 }
215 if config.ThrottleEnable {
216 if config.ThrottleQPS <= 0 {
217 return fmt.Errorf("invalid audit batch %s throttle QPS %v, must be a positive number", pluginName, config.ThrottleQPS)
218 }
219 if config.ThrottleBurst <= 0 {
220 return fmt.Errorf("invalid audit batch %s throttle burst %v, must be a positive number", pluginName, config.ThrottleBurst)
221 }
222 }
223 return nil
224 }
225
226 var knownGroupVersions = []schema.GroupVersion{
227 auditv1.SchemeGroupVersion,
228 }
229
230 func validateGroupVersionString(groupVersion string) error {
231 gv, err := schema.ParseGroupVersion(groupVersion)
232 if err != nil {
233 return err
234 }
235 if !knownGroupVersion(gv) {
236 return fmt.Errorf("invalid group version, allowed versions are %q", knownGroupVersions)
237 }
238 if gv != auditv1.SchemeGroupVersion {
239 klog.Warningf("%q is deprecated and will be removed in a future release, use %q instead", gv, auditv1.SchemeGroupVersion)
240 }
241 return nil
242 }
243
244 func knownGroupVersion(gv schema.GroupVersion) bool {
245 for _, knownGv := range knownGroupVersions {
246 if gv == knownGv {
247 return true
248 }
249 }
250 return false
251 }
252
253 func (o *AuditOptions) AddFlags(fs *pflag.FlagSet) {
254 if o == nil {
255 return
256 }
257
258 fs.StringVar(&o.PolicyFile, "audit-policy-file", o.PolicyFile,
259 "Path to the file that defines the audit policy configuration.")
260
261 o.LogOptions.AddFlags(fs)
262 o.LogOptions.BatchOptions.AddFlags(pluginlog.PluginName, fs)
263 o.LogOptions.TruncateOptions.AddFlags(pluginlog.PluginName, fs)
264 o.WebhookOptions.AddFlags(fs)
265 o.WebhookOptions.BatchOptions.AddFlags(pluginwebhook.PluginName, fs)
266 o.WebhookOptions.TruncateOptions.AddFlags(pluginwebhook.PluginName, fs)
267 }
268
269 func (o *AuditOptions) ApplyTo(
270 c *server.Config,
271 ) error {
272 if o == nil {
273 return nil
274 }
275 if c == nil {
276 return fmt.Errorf("server config must be non-nil")
277 }
278
279 // 1. Build policy evaluator
280 evaluator, err := o.newPolicyRuleEvaluator()
281 if err != nil {
282 return err
283 }
284
285 // 2. Build log backend
286 var logBackend audit.Backend
287 w, err := o.LogOptions.getWriter()
288 if err != nil {
289 return err
290 }
291 if w != nil {
292 if evaluator == nil {
293 klog.V(2).Info("No audit policy file provided, no events will be recorded for log backend")
294 } else {
295 logBackend = o.LogOptions.newBackend(w)
296 }
297 }
298
299 // 3. Build webhook backend
300 var webhookBackend audit.Backend
301 if o.WebhookOptions.enabled() {
302 if evaluator == nil {
303 klog.V(2).Info("No audit policy file provided, no events will be recorded for webhook backend")
304 } else {
305 if c.EgressSelector != nil {
306 var egressDialer utilnet.DialFunc
307 egressDialer, err = c.EgressSelector.Lookup(egressselector.ControlPlane.AsNetworkContext())
308 if err != nil {
309 return err
310 }
311 webhookBackend, err = o.WebhookOptions.newUntruncatedBackend(egressDialer)
312 } else {
313 webhookBackend, err = o.WebhookOptions.newUntruncatedBackend(nil)
314 }
315 if err != nil {
316 return err
317 }
318 }
319 }
320
321 groupVersion, err := schema.ParseGroupVersion(o.WebhookOptions.GroupVersionString)
322 if err != nil {
323 return err
324 }
325
326 // 4. Apply dynamic options.
327 var dynamicBackend audit.Backend
328 if webhookBackend != nil {
329 // if only webhook is enabled wrap it in the truncate options
330 dynamicBackend = o.WebhookOptions.TruncateOptions.wrapBackend(webhookBackend, groupVersion)
331 }
332
333 // 5. Set the policy rule evaluator
334 c.AuditPolicyRuleEvaluator = evaluator
335
336 // 6. Join the log backend with the webhooks
337 c.AuditBackend = appendBackend(logBackend, dynamicBackend)
338
339 if c.AuditBackend != nil {
340 klog.V(2).Infof("Using audit backend: %s", c.AuditBackend)
341 }
342 return nil
343 }
344
345 func (o *AuditOptions) newPolicyRuleEvaluator() (audit.PolicyRuleEvaluator, error) {
346 if o.PolicyFile == "" {
347 return nil, nil
348 }
349
350 p, err := policy.LoadPolicyFromFile(o.PolicyFile)
351 if err != nil {
352 return nil, fmt.Errorf("loading audit policy file: %v", err)
353 }
354 return policy.NewPolicyRuleEvaluator(p), nil
355 }
356
357 func (o *AuditBatchOptions) AddFlags(pluginName string, fs *pflag.FlagSet) {
358 fs.StringVar(&o.Mode, fmt.Sprintf("audit-%s-mode", pluginName), o.Mode,
359 "Strategy for sending audit events. Blocking indicates sending events should block"+
360 " server responses. Batch causes the backend to buffer and write events"+
361 " asynchronously. Known modes are "+strings.Join(AllowedModes, ",")+".")
362 fs.IntVar(&o.BatchConfig.BufferSize, fmt.Sprintf("audit-%s-batch-buffer-size", pluginName),
363 o.BatchConfig.BufferSize, "The size of the buffer to store events before "+
364 "batching and writing. Only used in batch mode.")
365 fs.IntVar(&o.BatchConfig.MaxBatchSize, fmt.Sprintf("audit-%s-batch-max-size", pluginName),
366 o.BatchConfig.MaxBatchSize, "The maximum size of a batch. Only used in batch mode.")
367 fs.DurationVar(&o.BatchConfig.MaxBatchWait, fmt.Sprintf("audit-%s-batch-max-wait", pluginName),
368 o.BatchConfig.MaxBatchWait, "The amount of time to wait before force writing the "+
369 "batch that hadn't reached the max size. Only used in batch mode.")
370 fs.BoolVar(&o.BatchConfig.ThrottleEnable, fmt.Sprintf("audit-%s-batch-throttle-enable", pluginName),
371 o.BatchConfig.ThrottleEnable, "Whether batching throttling is enabled. Only used in batch mode.")
372 fs.Float32Var(&o.BatchConfig.ThrottleQPS, fmt.Sprintf("audit-%s-batch-throttle-qps", pluginName),
373 o.BatchConfig.ThrottleQPS, "Maximum average number of batches per second. "+
374 "Only used in batch mode.")
375 fs.IntVar(&o.BatchConfig.ThrottleBurst, fmt.Sprintf("audit-%s-batch-throttle-burst", pluginName),
376 o.BatchConfig.ThrottleBurst, "Maximum number of requests sent at the same "+
377 "moment if ThrottleQPS was not utilized before. Only used in batch mode.")
378 }
379
380 type ignoreErrorsBackend struct {
381 audit.Backend
382 }
383
384 func (i *ignoreErrorsBackend) ProcessEvents(ev ...*auditinternal.Event) bool {
385 i.Backend.ProcessEvents(ev...)
386 return true
387 }
388
389 func (i *ignoreErrorsBackend) String() string {
390 return fmt.Sprintf("ignoreErrors<%s>", i.Backend)
391 }
392
393 func (o *AuditBatchOptions) wrapBackend(delegate audit.Backend) audit.Backend {
394 if o.Mode == ModeBlockingStrict {
395 return delegate
396 }
397 if o.Mode == ModeBlocking {
398 return &ignoreErrorsBackend{Backend: delegate}
399 }
400 return pluginbuffered.NewBackend(delegate, o.BatchConfig)
401 }
402
403 func (o *AuditTruncateOptions) Validate(pluginName string) error {
404 config := o.TruncateConfig
405 if config.MaxEventSize <= 0 {
406 return fmt.Errorf("invalid audit truncate %s max event size %v, must be a positive number", pluginName, config.MaxEventSize)
407 }
408 if config.MaxBatchSize < config.MaxEventSize {
409 return fmt.Errorf("invalid audit truncate %s max batch size %v, must be greater than "+
410 "max event size (%v)", pluginName, config.MaxBatchSize, config.MaxEventSize)
411 }
412 return nil
413 }
414
415 func (o *AuditTruncateOptions) AddFlags(pluginName string, fs *pflag.FlagSet) {
416 fs.BoolVar(&o.Enabled, fmt.Sprintf("audit-%s-truncate-enabled", pluginName),
417 o.Enabled, "Whether event and batch truncating is enabled.")
418 fs.Int64Var(&o.TruncateConfig.MaxBatchSize, fmt.Sprintf("audit-%s-truncate-max-batch-size", pluginName),
419 o.TruncateConfig.MaxBatchSize, "Maximum size of the batch sent to the underlying backend. "+
420 "Actual serialized size can be several hundreds of bytes greater. If a batch exceeds this limit, "+
421 "it is split into several batches of smaller size.")
422 fs.Int64Var(&o.TruncateConfig.MaxEventSize, fmt.Sprintf("audit-%s-truncate-max-event-size", pluginName),
423 o.TruncateConfig.MaxEventSize, "Maximum size of the audit event sent to the underlying backend. "+
424 "If the size of an event is greater than this number, first request and response are removed, and "+
425 "if this doesn't reduce the size enough, event is discarded.")
426 }
427
428 func (o *AuditTruncateOptions) wrapBackend(delegate audit.Backend, gv schema.GroupVersion) audit.Backend {
429 if !o.Enabled {
430 return delegate
431 }
432 return plugintruncate.NewBackend(delegate, o.TruncateConfig, gv)
433 }
434
435 func (o *AuditLogOptions) AddFlags(fs *pflag.FlagSet) {
436 fs.StringVar(&o.Path, "audit-log-path", o.Path,
437 "If set, all requests coming to the apiserver will be logged to this file. '-' means standard out.")
438 fs.IntVar(&o.MaxAge, "audit-log-maxage", o.MaxAge,
439 "The maximum number of days to retain old audit log files based on the timestamp encoded in their filename.")
440 fs.IntVar(&o.MaxBackups, "audit-log-maxbackup", o.MaxBackups,
441 "The maximum number of old audit log files to retain. Setting a value of 0 will mean there's no restriction on the number of files.")
442 fs.IntVar(&o.MaxSize, "audit-log-maxsize", o.MaxSize,
443 "The maximum size in megabytes of the audit log file before it gets rotated.")
444 fs.StringVar(&o.Format, "audit-log-format", o.Format,
445 "Format of saved audits. \"legacy\" indicates 1-line text format for each event."+
446 " \"json\" indicates structured json format. Known formats are "+
447 strings.Join(pluginlog.AllowedFormats, ",")+".")
448 fs.StringVar(&o.GroupVersionString, "audit-log-version", o.GroupVersionString,
449 "API group and version used for serializing audit events written to log.")
450 fs.BoolVar(&o.Compress, "audit-log-compress", o.Compress, "If set, the rotated log files will be compressed using gzip.")
451 }
452
453 func (o *AuditLogOptions) Validate() []error {
454 // Check whether the log backend is enabled based on the options.
455 if !o.enabled() {
456 return nil
457 }
458
459 var allErrors []error
460
461 if err := validateBackendBatchOptions(pluginlog.PluginName, o.BatchOptions); err != nil {
462 allErrors = append(allErrors, err)
463 }
464 if err := o.TruncateOptions.Validate(pluginlog.PluginName); err != nil {
465 allErrors = append(allErrors, err)
466 }
467
468 if err := validateGroupVersionString(o.GroupVersionString); err != nil {
469 allErrors = append(allErrors, err)
470 }
471
472 // Check log format
473 if !sets.NewString(pluginlog.AllowedFormats...).Has(o.Format) {
474 allErrors = append(allErrors, fmt.Errorf("invalid audit log format %s, allowed formats are %q", o.Format, strings.Join(pluginlog.AllowedFormats, ",")))
475 }
476
477 // Check validities of MaxAge, MaxBackups and MaxSize of log options, if file log backend is enabled.
478 if o.MaxAge < 0 {
479 allErrors = append(allErrors, fmt.Errorf("--audit-log-maxage %v can't be a negative number", o.MaxAge))
480 }
481 if o.MaxBackups < 0 {
482 allErrors = append(allErrors, fmt.Errorf("--audit-log-maxbackup %v can't be a negative number", o.MaxBackups))
483 }
484 if o.MaxSize < 0 {
485 allErrors = append(allErrors, fmt.Errorf("--audit-log-maxsize %v can't be a negative number", o.MaxSize))
486 }
487
488 return allErrors
489 }
490
491 // Check whether the log backend is enabled based on the options.
492 func (o *AuditLogOptions) enabled() bool {
493 return o != nil && o.Path != ""
494 }
495
496 func (o *AuditLogOptions) getWriter() (io.Writer, error) {
497 if !o.enabled() {
498 return nil, nil
499 }
500
501 if o.Path == "-" {
502 return os.Stdout, nil
503 }
504
505 if err := o.ensureLogFile(); err != nil {
506 return nil, fmt.Errorf("ensureLogFile: %w", err)
507 }
508
509 return &lumberjack.Logger{
510 Filename: o.Path,
511 MaxAge: o.MaxAge,
512 MaxBackups: o.MaxBackups,
513 MaxSize: o.MaxSize,
514 Compress: o.Compress,
515 }, nil
516 }
517
518 func (o *AuditLogOptions) ensureLogFile() error {
519 if err := os.MkdirAll(filepath.Dir(o.Path), 0700); err != nil {
520 return err
521 }
522 mode := os.FileMode(0600)
523 f, err := os.OpenFile(o.Path, os.O_CREATE|os.O_APPEND|os.O_RDWR, mode)
524 if err != nil {
525 return err
526 }
527 return f.Close()
528 }
529
530 func (o *AuditLogOptions) newBackend(w io.Writer) audit.Backend {
531 groupVersion, _ := schema.ParseGroupVersion(o.GroupVersionString)
532 log := pluginlog.NewBackend(w, o.Format, groupVersion)
533 log = o.BatchOptions.wrapBackend(log)
534 log = o.TruncateOptions.wrapBackend(log, groupVersion)
535 return log
536 }
537
538 func (o *AuditWebhookOptions) AddFlags(fs *pflag.FlagSet) {
539 fs.StringVar(&o.ConfigFile, "audit-webhook-config-file", o.ConfigFile,
540 "Path to a kubeconfig formatted file that defines the audit webhook configuration.")
541 fs.DurationVar(&o.InitialBackoff, "audit-webhook-initial-backoff",
542 o.InitialBackoff, "The amount of time to wait before retrying the first failed request.")
543 fs.DurationVar(&o.InitialBackoff, "audit-webhook-batch-initial-backoff",
544 o.InitialBackoff, "The amount of time to wait before retrying the first failed request.")
545 fs.MarkDeprecated("audit-webhook-batch-initial-backoff",
546 "Deprecated, use --audit-webhook-initial-backoff instead.")
547 fs.StringVar(&o.GroupVersionString, "audit-webhook-version", o.GroupVersionString,
548 "API group and version used for serializing audit events written to webhook.")
549 }
550
551 func (o *AuditWebhookOptions) Validate() []error {
552 if !o.enabled() {
553 return nil
554 }
555
556 var allErrors []error
557 if err := validateBackendBatchOptions(pluginwebhook.PluginName, o.BatchOptions); err != nil {
558 allErrors = append(allErrors, err)
559 }
560 if err := o.TruncateOptions.Validate(pluginwebhook.PluginName); err != nil {
561 allErrors = append(allErrors, err)
562 }
563
564 if err := validateGroupVersionString(o.GroupVersionString); err != nil {
565 allErrors = append(allErrors, err)
566 }
567 return allErrors
568 }
569
570 func (o *AuditWebhookOptions) enabled() bool {
571 return o != nil && o.ConfigFile != ""
572 }
573
574 // newUntruncatedBackend returns a webhook backend without the truncate options applied
575 // this is done so that the same trucate backend can wrap both the webhook and dynamic backends
576 func (o *AuditWebhookOptions) newUntruncatedBackend(customDial utilnet.DialFunc) (audit.Backend, error) {
577 groupVersion, _ := schema.ParseGroupVersion(o.GroupVersionString)
578 webhook, err := pluginwebhook.NewBackend(o.ConfigFile, groupVersion, webhook.DefaultRetryBackoffWithInitialDelay(o.InitialBackoff), customDial)
579 if err != nil {
580 return nil, fmt.Errorf("initializing audit webhook: %v", err)
581 }
582 webhook = o.BatchOptions.wrapBackend(webhook)
583 return webhook, nil
584 }
585
586 // defaultWebhookBatchConfig returns the default BatchConfig used by the Webhook backend.
587 func defaultWebhookBatchConfig() pluginbuffered.BatchConfig {
588 return pluginbuffered.BatchConfig{
589 BufferSize: defaultBatchBufferSize,
590 MaxBatchSize: defaultBatchMaxSize,
591 MaxBatchWait: defaultBatchMaxWait,
592
593 ThrottleEnable: true,
594 ThrottleQPS: defaultBatchThrottleQPS,
595 ThrottleBurst: defaultBatchThrottleBurst,
596
597 AsyncDelegate: true,
598 }
599 }
600
601 // defaultLogBatchConfig returns the default BatchConfig used by the Log backend.
602 func defaultLogBatchConfig() pluginbuffered.BatchConfig {
603 return pluginbuffered.BatchConfig{
604 BufferSize: defaultBatchBufferSize,
605 // Batching is not useful for the log-file backend.
606 // MaxBatchWait ignored.
607 MaxBatchSize: 1,
608 ThrottleEnable: false,
609 // Asynchronous log threads just create lock contention.
610 AsyncDelegate: false,
611 }
612 }