func init() { log.SetFormatter(log.NewPrettyFormatter(os.Stdout, true)) apnsLogger = log.NewPackageLogger("apns-microservice", "apns") serverLogger = log.NewPackageLogger("apns-microservice", "http") log.SetGlobalLogLevel(log.INFO) apns.SetLogger(apnsLogger) server.SetLogger(serverLogger) }
func init() { raft.SetLogger(capnslog.NewPackageLogger("github.com/coreos/etcd", "raft")) expvar.Publish("raft.status", expvar.Func(func() interface{} { raftStatusMu.Lock() defer raftStatusMu.Unlock() return raftStatus() })) }
func Example() { var plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "clientv3") clientv3.SetLogger(plog) cli, err := clientv3.New(clientv3.Config{ Endpoints: endpoints, DialTimeout: dialTimeout, }) if err != nil { log.Fatal(err) } defer cli.Close() // make sure to close the client _, err = cli.Put(context.TODO(), "foo", "bar") if err != nil { log.Fatal(err) } }
"fmt" "net" "net/http" "path" "github.com/coreos/etcd/etcdserver" "github.com/coreos/etcd/etcdserver/api/v2http" "github.com/coreos/etcd/pkg/cors" runtimeutil "github.com/coreos/etcd/pkg/runtime" "github.com/coreos/etcd/pkg/transport" "github.com/coreos/etcd/pkg/types" "github.com/coreos/etcd/rafthttp" "github.com/coreos/pkg/capnslog" ) var plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "embed") const ( // internal fd usage includes disk usage and transport usage. // To read/write snapshot, snap pkg needs 1. In normal case, wal pkg needs // at most 2 to read/lock/write WALs. One case that it needs to 2 is to // read all logs after some snapshot index, which locates at the end of // the second last and the head of the last. For purging, it needs to read // directory, so it needs 1. For fd monitor, it needs 1. // For transport, rafthttp builds two long-polling connections and at most // four temporary connections with each member. There are at most 9 members // in a cluster, so it should reserve 96. // For the safety, we set the total reserved number to 150. reservedInternalFDNum = 150 )
// See the License for the specific language governing permissions and // limitations under the License. package tcpproxy import ( "io" "net" "sync" "time" "github.com/coreos/pkg/capnslog" ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd/proxy", "tcpproxy") ) type remote struct { mu sync.Mutex addr string inactive bool } func (r *remote) inactivate() { r.mu.Lock() defer r.mu.Unlock() r.inactive = true } func (r *remote) tryReactivate() error {
// // 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 pbutil defines interfaces for handling Protocol Buffer objects. package pbutil import "github.com/coreos/pkg/capnslog" var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd/pkg", "pbutil") ) type Marshaler interface { Marshal() (data []byte, err error) } type Unmarshaler interface { Unmarshal(data []byte) error } func MustMarshal(m Marshaler) []byte { d, err := m.Marshal() if err != nil { plog.Panicf("marshal should never fail (%v)", err) }
// See the License for the specific language governing permissions and // limitations under the License. package redhatrelease import ( "regexp" "strings" "github.com/coreos/clair/database" "github.com/coreos/clair/worker/detectors" "github.com/coreos/pkg/capnslog" ) var ( log = capnslog.NewPackageLogger("github.com/coreos/clair", "worker/detectors/namespace/redhatrelease") centosReleaseRegexp = regexp.MustCompile(`(?P<os>[^\s]*) (Linux release|release) (?P<version>[\d]+)`) redhatReleaseRegexp = regexp.MustCompile(`(?P<os>Red Hat Enterprise Linux) (Client release|Server release|Workstation release) (?P<version>[\d]+)`) ) // RedhatReleaseNamespaceDetector implements NamespaceDetector and detects the OS from the // /etc/centos-release, /etc/redhat-release and /etc/system-release files. // // Typically for CentOS and Red-Hat like systems // eg. CentOS release 5.11 (Final) // eg. CentOS release 6.6 (Final) // eg. CentOS Linux release 7.1.1503 (Core) // eg. Red Hat Enterprise Linux Server release 7.2 (Maipo) type RedhatReleaseNamespaceDetector struct{}
import ( "encoding/json" "fmt" "net/http" "time" "github.com/coreos/pkg/capnslog" "github.com/coreos/pkg/timeutil" "github.com/jonboulle/clockwork" phttp "github.com/coreos/go-oidc/http" "github.com/coreos/go-oidc/oauth2" ) var ( log = capnslog.NewPackageLogger("github.com/coreos/go-oidc", "http") ) const ( MaximumProviderConfigSyncInterval = 24 * time.Hour MinimumProviderConfigSyncInterval = time.Minute discoveryConfigPath = "/.well-known/openid-configuration" ) // internally configurable for tests var minimumProviderConfigSyncInterval = MinimumProviderConfigSyncInterval type ProviderConfig struct { Issuer string `json:"issuer"` AuthEndpoint string `json:"authorization_endpoint"`
func init() { grpclog.SetLogger(capnslog.NewPackageLogger("github.com/coreos/etcd/etcdserver", "v3rpc/grpc")) }
// 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 httptypes import ( "encoding/json" "net/http" "github.com/coreos/pkg/capnslog" ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd/etcdserver/etcdhttp", "httptypes") ) type HTTPError struct { Message string `json:"message"` // Code is the HTTP status code Code int `json:"-"` } func (e HTTPError) Error() string { return e.Message } func (e HTTPError) WriteTo(w http.ResponseWriter) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(e.Code)
// 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 transport import ( "errors" "net" "github.com/coreos/etcd/pkg/runtime" "github.com/coreos/pkg/capnslog" ) var plog = capnslog.NewPackageLogger("github.com/coreos/etcd/pkg", "transport") type LimitedConnListener struct { net.Listener RuntimeFDLimit uint64 } func (l *LimitedConnListener) Accept() (net.Conn, error) { conn, err := l.Listener.Accept() if err != nil { return nil, err } n, err := runtime.FDUsage() // Check whether fd number in use exceeds the set limit. if err == nil && n >= l.RuntimeFDLimit {
package torus import ( "encoding/binary" "errors" "fmt" "golang.org/x/net/context" "github.com/coreos/pkg/capnslog" "github.com/coreos/torus/models" ) var BlockLog = capnslog.NewPackageLogger("github.com/coreos/torus", "blocklog") type ( // VolumeID represents a unique identifier for a Volume. VolumeID uint64 // IndexID represents a unique identifier for an Index. IndexID uint64 // INodeID represents a unique identifier for an INode. INodeID uint64 BlockType uint16 ) const ( TypeBlock BlockType = iota TypeINode
package compactor import ( "sync" "time" pb "github.com/coreos/etcd/etcdserver/etcdserverpb" "github.com/coreos/etcd/mvcc" "github.com/coreos/pkg/capnslog" "github.com/jonboulle/clockwork" "golang.org/x/net/context" ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "compactor") ) const ( checkCompactionInterval = 5 * time.Minute ) type Compactable interface { Compact(ctx context.Context, r *pb.CompactionRequest) (*pb.CompactionResponse, error) } type RevGetter interface { Rev() int64 } type Periodic struct {
"os" "sync" "syscall" "time" "github.com/coreos/torus/block" "github.com/coreos/pkg/capnslog" "github.com/mdlayher/aoe" "github.com/mdlayher/raw" "golang.org/x/net/bpf" "golang.org/x/net/context" ) var ( clog = capnslog.NewPackageLogger("github.com/coreos/torus", "aoe") broadcastAddr = net.HardwareAddr([]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}) ) type Server struct { dfs *block.BlockVolume dev Device ctx context.Context cancel context.CancelFunc wg *sync.WaitGroup major uint16 minor uint8
// 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 httptypes import ( "encoding/json" "net/http" "github.com/coreos/pkg/capnslog" ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "etcdserver/api/v2http/httptypes") ) type HTTPError struct { Message string `json:"message"` // Code is the HTTP status code Code int `json:"-"` } func (e HTTPError) Error() string { return e.Message } func (e HTTPError) WriteTo(w http.ResponseWriter) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(e.Code)
"sync" "time" "github.com/coreos/etcd/etcdserver/stats" "github.com/coreos/etcd/pkg/logutil" "github.com/coreos/etcd/pkg/transport" "github.com/coreos/etcd/pkg/types" "github.com/coreos/etcd/raft" "github.com/coreos/etcd/raft/raftpb" "github.com/coreos/etcd/snap" "github.com/coreos/pkg/capnslog" "github.com/xiang90/probing" "golang.org/x/net/context" ) var plog = logutil.NewMergeLogger(capnslog.NewPackageLogger("github.com/coreos/etcd", "rafthttp")) type Raft interface { Process(ctx context.Context, m raftpb.Message) error IsIDRemoved(id uint64) bool ReportUnreachable(id uint64) ReportSnapshot(id uint64, status raft.SnapshotStatus) } type Transporter interface { // Start starts the given Transporter. // Start MUST be called before calling other functions in the interface. Start() error // Handler returns the HTTP handler of the transporter. // A transporter HTTP handler handles the HTTP requests // from remote peers.
package flags import ( "flag" "fmt" "net/url" "os" "strings" "github.com/coreos/etcd/pkg/transport" "github.com/coreos/pkg/capnslog" ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd/pkg", "flags") ) // DeprecatedFlag encapsulates a flag that may have been previously valid but // is now deprecated. If a DeprecatedFlag is set, an error occurs. type DeprecatedFlag struct { Name string } func (f *DeprecatedFlag) Set(_ string) error { return fmt.Errorf(`flag "-%s" is no longer supported.`, f.Name) } func (f *DeprecatedFlag) String() string { return "" }
"net/url" "path" "sort" "strconv" "strings" "time" "github.com/coreos/etcd/client" "github.com/coreos/etcd/pkg/types" "github.com/coreos/pkg/capnslog" "github.com/jonboulle/clockwork" "golang.org/x/net/context" ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "discovery") ErrInvalidURL = errors.New("discovery: invalid URL") ErrBadSizeKey = errors.New("discovery: size key is bad") ErrSizeNotFound = errors.New("discovery: size key not found") ErrTokenNotFound = errors.New("discovery: token not found") ErrDuplicateID = errors.New("discovery: found duplicate id") ErrDuplicateName = errors.New("discovery: found duplicate name") ErrFullCluster = errors.New("discovery: cluster is full") ErrTooManyRetries = errors.New("discovery: too many retries") ErrBadDiscoveryEndpoint = errors.New("discovery: bad discovery endpoint") ) var ( // Number of retries discovery will attempt before giving up and erroring out. nRetries = uint(math.MaxUint32)
"github.com/coreos/torus" "github.com/coreos/torus/metadata" "github.com/coreos/torus/models" "github.com/coreos/torus/ring" etcdv3 "github.com/coreos/etcd/clientv3" "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes" "github.com/coreos/pkg/capnslog" "github.com/prometheus/client_golang/prometheus" "golang.org/x/net/context" ) // Package rule for etcd keys: always put the static parts first, followed by // the variables. This makes range gets a lot easier. var clog = capnslog.NewPackageLogger("github.com/coreos/torus", "etcd") const ( KeyPrefix = "/github.com/coreos/torus/" peerTimeoutMax = 50 * time.Second ) var ( promAtomicRetries = prometheus.NewCounterVec(prometheus.CounterOpts{ Name: "torus_etcd_atomic_retries", Help: "Number of times an atomic update failed and needed to be retried", }, []string{"key"}) promOps = prometheus.NewCounterVec(prometheus.CounterOpts{ Name: "torus_etcd_base_ops_total", Help: "Number of times an atomic update failed and needed to be retried", }, []string{"kind"})
var ( electionTicks = 10 // integration test uses well-known ports to listen for each running member, // which ensures restarted member could listen on specific port again. nextListenPort int64 = 21000 testTLSInfo = transport.TLSInfo{ KeyFile: "./fixtures/server.key.insecure", CertFile: "./fixtures/server.crt", TrustedCAFile: "./fixtures/ca.crt", ClientCertAuth: true, } plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "integration") ) type ClusterConfig struct { Size int PeerTLS *transport.TLSInfo ClientTLS *transport.TLSInfo DiscoveryURL string UseGRPC bool QuotaBackendBytes int64 } type cluster struct { cfg *ClusterConfig Members []*member }
"github.com/coreos/clair/database" "github.com/coreos/clair/updater" cerrors "github.com/coreos/clair/utils/errors" "github.com/coreos/clair/utils/types" "github.com/coreos/pkg/capnslog" ) const ( dataFeedURL string = "http://static.nvd.nist.gov/feeds/xml/cve/nvdcve-2.0-%s.xml.gz" dataFeedMetaURL string = "http://static.nvd.nist.gov/feeds/xml/cve/nvdcve-2.0-%s.meta" metadataKey string = "NVD" ) var ( log = capnslog.NewPackageLogger("github.com/coreos/clair", "updater/fetchers/metadata_fetchers") ) type NVDMetadataFetcher struct { localPath string dataFeedHashes map[string]string lock sync.Mutex metadata map[string]NVDMetadata } type NVDMetadata struct { CVSSv2 NVDmetadataCVSSv2 } type NVDmetadataCVSSv2 struct {
import ( "net/http" "sync" "time" "github.com/coreos/etcd/etcdserver/stats" "github.com/coreos/etcd/pkg/types" "github.com/coreos/etcd/raft" "github.com/coreos/etcd/raft/raftpb" "github.com/coreos/pkg/capnslog" "github.com/xiang90/probing" "golang.org/x/net/context" ) var plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "rafthttp") type Raft interface { Process(ctx context.Context, m raftpb.Message) error IsIDRemoved(id uint64) bool ReportUnreachable(id uint64) ReportSnapshot(id uint64, status raft.SnapshotStatus) } type Transporter interface { // Handler returns the HTTP handler of the transporter. // A transporter HTTP handler handles the HTTP requests // from remote peers. // The handler MUST be used to handle RaftPrefix(/raft) // endpoint. Handler() http.Handler
import ( "io/ioutil" "net" "net/http" "strconv" "time" "crypto/tls" "crypto/x509" "github.com/coreos/clair/utils" "github.com/coreos/pkg/capnslog" "github.com/tylerb/graceful" ) var log = capnslog.NewPackageLogger("github.com/coreos/clair", "api") // Config represents the configuration for the Main API. type Config struct { Port int TimeOut time.Duration CertFile, KeyFile, CAFile string } // RunMain launches the main API, which exposes every possible interactions // with clair. func RunMain(conf *Config, st *utils.Stopper) { log.Infof("starting API on port %d.", conf.Port) defer func() { log.Info("API stopped") st.End()
// Load all supported backends. _ "github.com/google/cayley/graph/bolt" _ "github.com/google/cayley/graph/leveldb" _ "github.com/google/cayley/graph/memstore" _ "github.com/google/cayley/graph/mongo" _ "github.com/google/cayley/graph/sql" ) const ( // fieldIs is the graph predicate defining the type of an entity. fieldIs = "is" ) var ( log = capnslog.NewPackageLogger("github.com/coreos/clair", "database") // ErrTransaction is an error that occurs when a database transaction fails. ErrTransaction = errors.New("database: transaction failed (concurrent modification?)") // ErrBackendException is an error that occurs when the database backend does // not work properly (ie. unreachable). ErrBackendException = errors.New("database: could not query backend") // ErrInconsistent is an error that occurs when a database consistency check // fails (ie. when an entity which is supposed to be unique is detected twice) ErrInconsistent = errors.New("database: inconsistent database") // ErrCantOpen is an error that occurs when the database could not be opened ErrCantOpen = errors.New("database: could not open database") store *cayley.Handle )
// 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 stats defines a standard interface for etcd cluster statistics. package stats import "github.com/coreos/pkg/capnslog" var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd/etcdserver", "stats") ) type Stats interface { // SelfStats returns the struct representing statistics of this server SelfStats() []byte // LeaderStats returns the statistics of all followers in the cluster // if this server is leader. Otherwise, nil is returned. LeaderStats() []byte // StoreStats returns statistics of the store backing this EtcdServer StoreStats() []byte }
package main import "github.com/coreos/pkg/capnslog" import "os" var plog = capnslog.NewPackageLogger("soundwave", "main") func main() { capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) capnslog.SetGlobalLogLevel(capnslog.TRACE) plog.Debug("aaa") plog.Trace("aaa") plog.Info("aaa") plog.Notice("aaa") plog.Warning("aaa") plog.Error("aaa") plog.Fatal("aaa") plog.Panic("aaa") }
// See the License for the specific language governing permissions and // limitations under the License. package main import ( "flag" "fmt" "net/http" "strings" "github.com/coreos/pkg/capnslog" "github.com/prometheus/client_golang/prometheus" ) var plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "etcd-tester") func main() { endpointStr := flag.String("agent-endpoints", "localhost:9027", "HTTP RPC endpoints of agents. Do not specify the schema.") datadir := flag.String("data-dir", "agent.etcd", "etcd data directory location on agent machine.") stressKeySize := flag.Int("stress-key-size", 100, "the size of each key written into etcd.") stressKeySuffixRange := flag.Int("stress-key-count", 250000, "the count of key range written into etcd.") limit := flag.Int("limit", 3, "the limit of rounds to run failure set.") schedCases := flag.String("schedule-cases", "", "test case schedule") isV2Only := flag.Bool("v2-only", false, "'true' to run V2 only tester.") flag.Parse() endpoints := strings.Split(*endpointStr, ",") c, err := newCluster(endpoints, *datadir, *stressKeySize, *stressKeySuffixRange, *isV2Only) if err != nil {
crcType snapshotType // warnSyncDuration is the amount of time allotted to an fsync before // logging a warning warnSyncDuration = time.Second ) var ( // SegmentSizeBytes is the preallocated size of each wal segment file. // The actual size might be larger than this. In general, the default // value should be used, but this is defined as an exported variable // so that tests can set a different segment size. SegmentSizeBytes int64 = 64 * 1000 * 1000 // 64MB plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "wal") ErrMetadataConflict = errors.New("wal: conflicting metadata found") ErrFileNotFound = errors.New("wal: file not found") ErrCRCMismatch = errors.New("wal: crc mismatch") ErrSnapshotMismatch = errors.New("wal: snapshot mismatch") ErrSnapshotNotFound = errors.New("wal: snapshot not found") crcTable = crc32.MakeTable(crc32.Castagnoli) ) // WAL is a logical representation of the stable storage. // WAL is either in read mode or append mode but not both. // A newly created WAL is in append mode, and ready for appending records. // A just opened WAL is in read mode, and ready for reading records. // The WAL will be ready for appending after reading out all the previous records. type WAL struct {
purgeFileInterval = 30 * time.Second // monitorVersionInterval should be smaller than the timeout // on the connection. Or we will not be able to reuse the connection // (since it will timeout). monitorVersionInterval = rafthttp.ConnWriteTimeout - time.Second databaseFilename = "db" // max number of in-flight snapshot messages etcdserver allows to have // This number is more than enough for most clusters with 5 machines. maxInFlightMsgSnap = 16 releaseDelayAfterSnapshot = 30 * time.Second ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "etcdserver") storeMemberAttributeRegexp = regexp.MustCompile(path.Join(membership.StoreMembersPrefix, "[[:xdigit:]]{1,16}", "attributes")) ) func init() { rand.Seed(time.Now().UnixNano()) expvar.Publish( "file_descriptor_limit", expvar.Func( func() interface{} { n, _ := runtime.FDLimit() return n }, ),
import ( "sort" "github.com/coreos/etcd/etcdserver" "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes" pb "github.com/coreos/etcd/etcdserver/etcdserverpb" "github.com/coreos/etcd/lease" "github.com/coreos/etcd/storage" "github.com/coreos/pkg/capnslog" "golang.org/x/net/context" "google.golang.org/grpc" "google.golang.org/grpc/codes" ) var ( plog = capnslog.NewPackageLogger("github.com/coreos/etcd/etcdserver/api", "v3rpc") // Max operations per txn list. For example, Txn.Success can have at most 128 operations, // and Txn.Failure can have at most 128 operations. MaxOpsPerTxn = 128 ) type kvServer struct { clusterID int64 memberID int64 raftTimer etcdserver.RaftTimer kv etcdserver.RaftKV } func NewKVServer(s *etcdserver.EtcdServer) pb.KVServer {