v.io: v.io/x/ref/lib/flags Index | Files | Directories

package flags

import "v.io/x/ref/lib/flags"

Package flags implements utilities to augment the standard Go flag package. It defines commonly used Vanadium flags, and implementations of the flag.Value interface for those flags to ensure that only valid values of those flags are supplied. Some of these flags may also be specified using environment variables directly and are documented accordingly; in these cases the command line value takes precedence over the environment variable.

Flags are defined as 'groups' of related flags so that the caller may choose which ones to use without having to be burdened with the full set. The groups may be used directly or via the Flags type that aggregates multiple groups. In all cases, the flags are registered with a supplied flag.FlagSet and hence are not forced onto the command line unless the caller passes in flag.CommandLine as the flag.FlagSet to use.

In general, this package will be used by vanadium profiles and the runtime implementations, but can also be used by any application that wants access to the flags and environment variables it supports.

Default values are provided for all flags that can be overridden either by calling functions in this package, or globally, by providing an alternative implementation of the ./flags/sitedefaults package. sitedefaults is sub-module that can be overridden using a 'replace' statement in go.mod to provide site specific defaults.

Index

Package Files

defaults.go doc.go flags.go listen.go namespace.go permissions.go sitedefaults.go test_site_defaults.go virtualized.go

func DefaultCredentialsDir Uses

func DefaultCredentialsDir() string

DefaultCredentialsDir returns the current default for --v23.credentials taking V23_CREDENTIALS into account

func DefaultCredentialsDirNoEnv Uses

func DefaultCredentialsDirNoEnv() string

DefaultCredentialsDirNoEnv returns the current default for --v23.credentials ignoring V23_CREDENTIALS

func DefaultHostPort Uses

func DefaultHostPort() string

DefaultHostPort returns the current default host port.

func DefaultI18nCatalogue Uses

func DefaultI18nCatalogue() string

DefaultI18nCatalogue returns the current default for --v23.i18n-catalogue. taking V23_V23_I18N_CATALOGUE into account.

func DefaultI18nCatalogueNoEnv Uses

func DefaultI18nCatalogueNoEnv() string

DefaultI18nCatalogueNoEnv returns the current default for --v23.i18n-catalogue ignoring V23_I18N_CATALOGUE.

func DefaultNamespaceRoots Uses

func DefaultNamespaceRoots() []string

DefaultNamespaceRoots returns the current default value of -v23.namespace.root taking the environment variables V23_NAMESPACE_ROOT0... into account.

func DefaultNamespaceRootsNoEnv Uses

func DefaultNamespaceRootsNoEnv() []string

DefaultNamespaceRootsNoEnv returns the current default value of -v23.namespace.root ignoring V23_NAMESPACE_ROOT0...

func DefaultPermissions Uses

func DefaultPermissions() map[string]string

DefaultPermissions returns the current default values for --v23.permissions.file as a map.

func DefaultPermissionsLiteral Uses

func DefaultPermissionsLiteral() string

DefaultPermissionsLiteral returns the current default value for --v23.permissions.literal.

func DefaultProtocol Uses

func DefaultProtocol() string

DefaultProtocol returns the current default protocol.

func DefaultProxy Uses

func DefaultProxy() string

DefaultProxy returns the current default proxy.

func DefaultProxyLimit Uses

func DefaultProxyLimit() int

DefaultProxyLimit returns the current default proxy limit.

func DefaultProxyPolicy Uses

func DefaultProxyPolicy() rpc.ProxyPolicy

DefaultProxyPolicy returns the current default proxy policy.

func RegisterListenFlags Uses

func RegisterListenFlags(fs *flag.FlagSet, f *ListenFlags) error

RegisterListenFlags registers the supplied ListenFlags variable with the supplied FlagSet.

func RegisterPermissionsFlags Uses

func RegisterPermissionsFlags(fs *flag.FlagSet, f *PermissionsFlags) error

RegisterPermissionsFlags registers the supplied PermissionsFlags with the supplied FlagSet.

func RegisterRuntimeFlags Uses

func RegisterRuntimeFlags(fs *flag.FlagSet, f *RuntimeFlags) error

RegisterRuntimeFlags registers the supplied RuntimeFlags variable with the supplied FlagSet.

func RegisterVirtualizedFlags Uses

func RegisterVirtualizedFlags(fs *flag.FlagSet, f *VirtualizedFlags) error

RegisterVirtualizedFlags registers the supplied VirtualizedFlags variable with the supplied FlagSet.

func SetDefaultCredentialsDir Uses

func SetDefaultCredentialsDir(credentialsDir string)

SetDefaultCredentialsDir sets the default value for --v23.credentials. It must be called before flags are parsed for it to take effect.

func SetDefaultHostPort Uses

func SetDefaultHostPort(s string)

SetDefaultHostPort sets the default host and port used when --v23.tcp.address is not provided. It must be called before flags are parsed for it to take effect.

func SetDefaultI18nCatalogue Uses

func SetDefaultI18nCatalogue(i18nCatalogue string)

SetDefaultI18nCatalogue sets the default value for --v23.i18n-catalogue. It must be called before flags are parsed for it to take effect.

func SetDefaultNamespaceRoots Uses

func SetDefaultNamespaceRoots(roots ...string)

SetDefaultNamespaceRoots sets the default value for --v23.namespace.root

func SetDefaultPermissions Uses

func SetDefaultPermissions(name, file string)

SetDefaultPermissions adds a name, file pair to the default value for --v23.permissions.file.

func SetDefaultPermissionsLiteral Uses

func SetDefaultPermissionsLiteral(literal string)

SetDefaultPermissionsLiteral sets the default value for --v23.permissions.literal.

func SetDefaultProtocol Uses

func SetDefaultProtocol(protocol string)

SetDefaultProtocol sets the default protocol used when --v23.tcp.protocol is not provided. It must be called before flags are parsed for it to take effect.

func SetDefaultProxy Uses

func SetDefaultProxy(s string)

SetDefaultProxy sets the default proxy used when --v23.proxy is not provided. It must be called before flags are parsed for it to take effect.

func SetDefaultProxyLimit Uses

func SetDefaultProxyLimit(l int)

SetDefaultProxyLimit sets the default proxy used when --v23.proxy.limit is not provided. It must be called before flags are parsed for it to take effect.

func SetDefaultProxyPolicy Uses

func SetDefaultProxyPolicy(p rpc.ProxyPolicy)

SetDefaultProxyPolicy sets the default proxy used when --v23.proxy.policy is not provided. It must be called before flags are parsed for it to take effect.

func SetDefaultVirtualizedFlagValues Uses

func SetDefaultVirtualizedFlagValues(values VirtualizedFlagDefaults)

SetDefaultVirtualizedFlagValues sets the default values to use for the Virtualized flags group.

type FlagGroup Uses

type FlagGroup int

FlagGroup is the type for identifying groups of related flags.

const (
    // Runtime identifies the flags and associated environment variables
    // used by the Vanadium process runtime. Namely:
    // --v23.namespace.root (which may be repeated to supply multiple values)
    // --v23.credentials
    // --v23.i18n-catalogue
    // --v23.vtrace.sample-rate
    // --v23.vtrace.dump-on-shutdown
    // --v23.vtrace.cache-size
    // --v23.vtrace.collect-regexp
    Runtime FlagGroup = iota
    // Listen identifies the flags typically required to configure
    // rpc.ListenSpec. Namely:
    // --v23.tcp.protocol
    // --v23.tcp.address
    // --v23.proxy
    // --v23.proxy.policy
    // --v23.proxy.limit
    Listen
    // Permissions identifies the flags typically required to configure
    // authorization.
    // --v23.permissions.file (which may be repeated to supply multiple values)
    // Permissions files are named - i.e. --v23.permissions.file=<name>:<file>
    // with the name "runtime" reserved for use by the runtime. "file" is
    // a JSON-encoded representation of the Permissions type defined in the
    // VDL package v.io/v23/security/access
    // --v23.permissions.literal (which may be repeated to supply multiple values
    // which will be concatenated)
    // This flag allows permissions to specified directly on the command line.
    Permissions
    // Virtualized identifies the flags typically required to configure a server
    // running in some form of virtualized or isolated environment such
    // as AWS, GCE or within a docker container.
    // v23.virtualized.docker
    // v23.virtualized.provider
    // v23.virtualized.discover-public-address
    // v23.virtualized.tcp.public-protocol
    // v23.virtualized.tcp.public-address
    // v23.virtualized.dns.public-name
    Virtualized
)

type Flags Uses

type Flags struct {
    FlagSet *flag.FlagSet
    // contains filtered or unexported fields
}

Flags represents the set of flag groups created by a call to CreateAndRegister.

func CreateAndRegister Uses

func CreateAndRegister(fs *flag.FlagSet, groups ...FlagGroup) (*Flags, error)

CreateAndRegister creates a new set of flag groups as specified by the supplied flag group parameters and registers them with the supplied flag.FlagSet.

func (*Flags) Args Uses

func (f *Flags) Args() []string

Args returns the unparsed args, as per flag.Args.

func (*Flags) HasGroup Uses

func (f *Flags) HasGroup(group FlagGroup) bool

HasGroup returns group if the supplied FlagGroup has been created for these Flags.

func (*Flags) ListenFlags Uses

func (f *Flags) ListenFlags() ListenFlags

ListenFlags returns a copy of the Listen flag group stored in Flags. This copy will contain default values if the Listen flag group was not specified when CreateAndRegister was called. The HasGroup method can be used for testing to see if any given group was configured.

func (*Flags) Parse Uses

func (f *Flags) Parse(args []string, cfg map[string]string) error

Parse parses the supplied args, as per flag.Parse. The config can optionally specify flag overrides. Any default values modified since the last call to Parse will used.

func (*Flags) PermissionsFlags Uses

func (f *Flags) PermissionsFlags() PermissionsFlags

PermissionsFlags returns a copy of the Permissions flag group stored in Flags. This copy will contain default values if the Permissions flag group was not specified when CreateAndRegister was called. The HasGroup method can be used for testing to see if any given group was configured.

func (*Flags) RuntimeFlags Uses

func (f *Flags) RuntimeFlags() RuntimeFlags

RuntimeFlags returns the Runtime flag subset stored in its Flags instance.

func (*Flags) VirtualizedFlags Uses

func (f *Flags) VirtualizedFlags() VirtualizedFlags

VirtualizedFlags returns a copy of the Virtualized flag group stored in Flags. This copy will contain default values if the Virtualized flag group was not specified when CreateAndRegister was called. The HasGroup method can be used for testing to see if any given group was configured.

type HostPortFlag Uses

type HostPortFlag struct {
    Host string
    Port string
}

HostPortFlag implements flag.Value to provide validation of the command line value it is set to. The allowed format is <host>:<port>. The host may be specified as a hostname or as an IP address (v4 or v6). A DNS hostname is never resolved.

func (HostPortFlag) Get Uses

func (ip HostPortFlag) Get() interface{}

Get implements flag.Getter.

func (*HostPortFlag) Set Uses

func (ip *HostPortFlag) Set(s string) error

Set implements flag.Value.

func (HostPortFlag) String Uses

func (ip HostPortFlag) String() string

Implements flag.Value.String

type IPFlag Uses

type IPFlag struct{ net.IP }

IPFlag implements flag.Value in order to provide validation of IP addresses in the flag package.

func (IPFlag) Get Uses

func (ip IPFlag) Get() interface{}

Get implements flag.Getter.

func (*IPFlag) Set Uses

func (ip *IPFlag) Set(s string) error

Set implements flag.Value.

func (IPFlag) String Uses

func (ip IPFlag) String() string

Implements flag.Value.String

type IPHostPortFlag Uses

type IPHostPortFlag struct {
    Address string
    Host    string
    IP      []*net.IPAddr
    Port    string
}

IPHostPortFlag implements flag.Value to provide validation of the command line value it is set to. The allowed format is <host>:<port> in ip4 and ip6 formats. The host may be specified as a hostname or as an IP address (v4 or v6). If a hostname is used and it resolves to multiple IP addresses then all of those addresses are stored in IPHostPort.

func (IPHostPortFlag) Get Uses

func (ip IPHostPortFlag) Get() interface{}

Get implements flag.Getter.

func (*IPHostPortFlag) Set Uses

func (ip *IPHostPortFlag) Set(s string) error

Set implements flag.Value.

func (IPHostPortFlag) String Uses

func (ip IPHostPortFlag) String() string

Implements flag.Value.String

type ListenAddrs Uses

type ListenAddrs []struct {
    Protocol, Address string
}

ListenAddrs is the set of listen addresses captured from the command line. ListenAddrs mirrors rpc.ListenAddrs.

type ListenFlags Uses

type ListenFlags struct {
    Addrs       ListenAddrs
    Proxy       string             `cmdline:"v23.proxy,,object name of proxy service to use to export services across network boundaries"`
    ProxyPolicy ProxyPolicyFlag    `cmdline:"v23.proxy.policy,,policy for choosing from a set of available proxy instances"`
    ProxyLimit  int                `cmdline:"v23.proxy.limit,,'max number of proxies to connect to when the policy is to connect to all proxies; 0 implies all proxies'"`
    Protocol    tcpProtocolFlagVar `cmdline:"v23.tcp.protocol,,protocol to listen with"`
    Addresses   ipHostPortFlagVar  `cmdline:"v23.tcp.address,,address to listen on"`
}

ListenFlags contains the values of the Listen flag group.

func CreateAndRegisterListenFlags Uses

func CreateAndRegisterListenFlags(fs *flag.FlagSet) (*ListenFlags, error)

CreateAndRegisterListenFlags creates and registers the ListenFlags group with the supplied flag.FlagSet.

func NewListenFlags Uses

func NewListenFlags() (*ListenFlags, error)

NewListenFlags creates a new ListenFlags with appropriate defaults.

type NamespaceRootFlag Uses

type NamespaceRootFlag struct {
    Roots []string
    // contains filtered or unexported fields
}

NamespaceRootFlag represents a flag.Value for --v23.namespace.root.

func (*NamespaceRootFlag) Set Uses

func (nsr *NamespaceRootFlag) Set(v string) error

Set implements flag.Value

func (*NamespaceRootFlag) String Uses

func (nsr *NamespaceRootFlag) String() string

String implements flag.Value.

type PermissionsFlag Uses

type PermissionsFlag struct {
    // contains filtered or unexported fields
}

PermissionsFlag represents a flag.Value for --v23.permissions.file

func (*PermissionsFlag) Set Uses

func (permsf *PermissionsFlag) Set(v string) error

Set implements flag.Value.

func (*PermissionsFlag) String Uses

func (permsf *PermissionsFlag) String() string

String implements flag.Value.

type PermissionsFlags Uses

type PermissionsFlags struct {
    // List of named Permissions files.
    Files PermissionsFlag `cmdline:"v23.permissions.file,,specify a perms file as <name>:<permsfile>"`

    // Literal permissions, override everything else.
    Literal PermissionsLiteralFlag `cmdline:"v23.permissions.literal,,explicitly specify the runtime perms as a JSON-encoded access.Permissions. Overrides all --v23.permissions.file flags"`
}

PermissionsFlags contains the values of the PermissionsFlags flag group.

func CreateAndRegisterPermissionsFlags Uses

func CreateAndRegisterPermissionsFlags(fs *flag.FlagSet) (*PermissionsFlags, error)

CreateAndRegisterPermissionsFlags creates and registers a PermissionsFlags with the supplied FlagSet.

func NewPermissionsFlags Uses

func NewPermissionsFlags() (*PermissionsFlags, error)

NewPermissionsFlags creates a PermissionsFlags with appropriate defaults.

func (PermissionsFlags) AddPermissionsFile Uses

func (af PermissionsFlags) AddPermissionsFile(arg string) error

AddPermissionsFile adds a permissions file, which must be in the same format as accepted by --v23.permissions.file

func (PermissionsFlags) AddPermissionsLiteral Uses

func (af PermissionsFlags) AddPermissionsLiteral(arg string) error

AddPermissionsLiteral adds another literal permissions statement.

func (PermissionsFlags) ExplicitlySpecified Uses

func (af PermissionsFlags) ExplicitlySpecified() bool

ExplicitlySpecified returns true if either of the permissions flags was explicitly set on the command line.

func (PermissionsFlags) PermissionsFile Uses

func (af PermissionsFlags) PermissionsFile(name string) string

PermissionsFile returns the file which is presumed to contain Permissions information associated with the supplied name parameter.

func (PermissionsFlags) PermissionsLiteral Uses

func (af PermissionsFlags) PermissionsLiteral() string

PermissionsLiteral returns the in-line literal permissions provided on the command line.

func (PermissionsFlags) PermissionsNamesAndFiles Uses

func (af PermissionsFlags) PermissionsNamesAndFiles() map[string]string

PermissionsNamesAndFiles returns the set of permission names and associated files specified using --v23.permissions.file.

type PermissionsLiteralFlag Uses

type PermissionsLiteralFlag struct {
    // contains filtered or unexported fields
}

PermissionsLiteralFlag represents a flag.Value for --v23.permissions.literal

func (*PermissionsLiteralFlag) Set Uses

func (permsl *PermissionsLiteralFlag) Set(v string) error

Set implements flag.Value.

func (*PermissionsLiteralFlag) String Uses

func (permsl *PermissionsLiteralFlag) String() string

String implements flag.Value.

type ProxyPolicyFlag Uses

type ProxyPolicyFlag rpc.ProxyPolicy

func (ProxyPolicyFlag) Get Uses

func (policy ProxyPolicyFlag) Get() interface{}

func (*ProxyPolicyFlag) Set Uses

func (policy *ProxyPolicyFlag) Set(s string) error

func (ProxyPolicyFlag) String Uses

func (policy ProxyPolicyFlag) String() string

func (ProxyPolicyFlag) Value Uses

func (policy ProxyPolicyFlag) Value() rpc.ProxyPolicy

type RuntimeFlags Uses

type RuntimeFlags struct {
    // NamespaceRoots may be initialized by ref.EnvNamespacePrefix* enivornment
    // variables as well as --v23.namespace.root. The command line
    // will override the environment.
    NamespaceRoots NamespaceRootFlag `cmdline:"v23.namespace.root,,local namespace root; can be repeated to provided multiple roots"`

    // Credentials may be initialized by the ref.EnvCredentials
    // environment variable. The command line will override the environment.
    // TODO(cnicolaou): provide flag.Value impl
    Credentials string `cmdline:"v23.credentials,,directory to use for storing security credentials"`

    // I18nCatalogue may be initialized by the ref.EnvI18nCatalogueFiles
    // environment variable.  The command line will override the
    // environment.
    I18nCatalogue string `cmdline:"v23.i18n-catalogue,,'18n catalogue files to load, comma separated'"`

    // VtraceFlags control various aspects of Vtrace.
    VtraceFlags
}

RuntimeFlags contains the values of the Runtime flag group.

func CreateAndRegisterRuntimeFlags Uses

func CreateAndRegisterRuntimeFlags(fs *flag.FlagSet) (*RuntimeFlags, error)

CreateAndRegisterRuntimeFlags creates and registers a RuntimeFlags with the supplied flag.FlagSet.

func NewRuntimeFlags Uses

func NewRuntimeFlags() (*RuntimeFlags, error)

NewRuntimeFlags creates a new RuntimeFlags with appropriate defaults.

type TCPProtocolFlag Uses

type TCPProtocolFlag struct {
    Protocol string
}

TCPProtocolFlag implements flag.Value to provide validation of the command line values passed to it: tcp, tcp4, tcp6, ws, ws4, ws6, wsh, wsh4, and wsh6 being the only allowed values.

func (TCPProtocolFlag) Get Uses

func (t TCPProtocolFlag) Get() interface{}

Get implements flag.Getter.

func (*TCPProtocolFlag) Set Uses

func (t *TCPProtocolFlag) Set(s string) error

Set implements flag.Value.

func (TCPProtocolFlag) String Uses

func (t TCPProtocolFlag) String() string

String implements flag.Value.

type VirtualizationProvider Uses

type VirtualizationProvider string

VirtualizationProvider identifies a particular virtualization provider/cloud computing vendor. Popular providers are defined here, but applications may chose to add define and act on others by creating additional runtime factories.

const (
    // Native is reserved for any/all non-virtualized environments.
    Native VirtualizationProvider = ""
    // AWS is reserved for Amazon Web Services.
    AWS VirtualizationProvider = "AWS"
    // GCP is reserved for Google's Compute Platform.
    GCP VirtualizationProvider = "GCP"
)

type VirtualizationProviderFlag Uses

type VirtualizationProviderFlag struct {
    Provider VirtualizationProvider
}

VirtualizationProviderFlag represents

func (VirtualizationProviderFlag) Get Uses

func (vp VirtualizationProviderFlag) Get() interface{}

Get implements flat.Getter.

func (*VirtualizationProviderFlag) Set Uses

func (vp *VirtualizationProviderFlag) Set(v string) error

Set implements flat.Value.

func (*VirtualizationProviderFlag) String Uses

func (vp *VirtualizationProviderFlag) String() string

String implements flat.Value.

type VirtualizedFlagDefaults Uses

type VirtualizedFlagDefaults struct {
    Dockerized                bool
    VirtualizationProvider    string
    PublicProtocol            string
    PublicAddress             string
    PublicDNSName             string
    AdvertisePrivateAddresses bool
}

VirtualizedFlagDefaults is used to set defaults for the Virtualized flag group.

func DefaultVirtualizedFlagValues Uses

func DefaultVirtualizedFlagValues() VirtualizedFlagDefaults

DefaultVirtualizedFlagValues returns the default values to use for the Virtualized flags group taking V23_VIRTUALIZATION_PROVIDER into account. In addition, if V23_EXPECT_GOOGLE_COMPUTE_ENGINE is set then GCP is assumed to be the virtualization provider. V23_EXPECT_GOOGLE_COMPUTE_ENGINE will be removed in the near future (as of 7/30/20). V23_VIRTUALIZATION_PROVIDER will override the effect of V23_EXPECT_GOOGLE_COMPUTE_ENGINE.

type VirtualizedFlags Uses

type VirtualizedFlags struct {
    Dockerized                bool                       `cmdline:"v23.virtualized.docker,,set if the process is running in a docker container and needs to configure itself differently therein"`
    VirtualizationProvider    VirtualizationProviderFlag `cmdline:"v23.virtualized.provider,,the name of the virtualization/cloud provider hosting this process if the process needs to configure itself differently therein"`
    DissallowNativeFallback   bool                       `cmdline:"v23.virtualized.disallow-native-fallback,,'if set, a failure to detect the requested virtualization provider will result in an error, otherwise, native mode is used'"`
    PublicProtocol            TCPProtocolFlag            `cmdline:"v23.virtualized.tcp.public-protocol,,if set the process will use this protocol for its entry in the mounttable"`
    PublicAddress             IPHostPortFlag             `cmdline:"v23.virtualized.tcp.public-address,,if set the process will use this address (resolving via dns if appropriate) for its entry in the mounttable"`
    PublicDNSName             HostPortFlag               `cmdline:"v23.virtualized.dns.public-name,,if set the process will use the supplied dns name (and port) without resolution for its entry in the mounttable"`
    AdvertisePrivateAddresses bool                       `cmdline:"v23.virtualized.advertise-private-addresses,,if set the process will also advertise its private addresses"`
}

VirtualizedFlags contains the values of the Virtualized flag group.

func CreateAndRegisterVirtualizedFlags Uses

func CreateAndRegisterVirtualizedFlags(fs *flag.FlagSet) (*VirtualizedFlags, error)

CreateAndRegisterVirtualizedFlags creates and registers the VirtualizedFlags group with the supplied flag.FlagSet.

func NewVirtualizedFlags Uses

func NewVirtualizedFlags() (*VirtualizedFlags, error)

NewVirtualizedFlags creates a new VirtualizedFlags with appropriate defaults.

type VtraceFlags Uses

type VtraceFlags struct {
    // VtraceSampleRate is the rate (from 0.0 - 1.0) at which
    // vtrace traces started by this process are sampled for collection.
    SampleRate float64 `cmdline:"v23.vtrace.sample-rate,,Rate (from 0.0 to 1.0) to sample vtrace traces"`

    // VtraceDumpOnShutdown tells the runtime to dump all stored traces
    // to Stderr at shutdown if true.
    DumpOnShutdown bool `cmdline:"v23.vtrace.dump-on-shutdown,true,'If true, dump all stored traces on runtime shutdown'"`

    // VtraceCacheSize is the number of traces to cache in memory.
    // TODO(mattr): Traces can be of widely varying size, we should have
    // some better measurement then just number of traces.
    CacheSize int `cmdline:"v23.vtrace.cache-size,1024,The number of vtrace traces to store in memory"`

    // LogLevel is the level of vlogs that should be collected as part of
    // the trace
    LogLevel int `cmdline:"v23.vtrace.v,,The verbosity level of the log messages to be captured in traces"`

    // SpanRegexp matches a regular expression against span names and
    // annotations and forces any trace matching trace to be collected.
    CollectRegexp string `cmdline:"v23.vtrace.collect-regexp,,Spans and annotations that match this regular expression will trigger trace collection"`
}

VtraceFlags represents the flags used to configure rpc tracing.

Directories

PathSynopsis
sitedefaults

Package flags imports 13 packages (graph) and is imported by 20 packages. Updated 2020-10-24. Refresh now. Tools for package owners.