本文整理汇总了Golang中github.com/facette/facette/pkg/logger.Log函数的典型用法代码示例。如果您正苦于以下问题:Golang Log函数的具体用法?Golang Log怎么用?Golang Log使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Log函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: startProviderWorkers
func (server *Server) startProviderWorkers() error {
server.providerWorkers = worker.NewWorkerPool()
logger.Log(logger.LevelDebug, "server", "declaring providers")
for _, prov := range server.providers {
connectorType, err := config.GetString(prov.Config.Connector, "type", true)
if err != nil {
return fmt.Errorf("provider `%s' connector: %s", prov.Name, err)
} else if _, ok := connector.Connectors[connectorType]; !ok {
return fmt.Errorf("provider `%s' uses unknown connector type `%s'", prov.Name, connectorType)
}
providerWorker := worker.NewWorker()
providerWorker.RegisterEvent(eventInit, workerProviderInit)
providerWorker.RegisterEvent(eventShutdown, workerProviderShutdown)
providerWorker.RegisterEvent(eventRun, workerProviderRun)
providerWorker.RegisterEvent(eventCatalogRefresh, workerProviderRefresh)
if err := providerWorker.SendEvent(eventInit, false, prov, connectorType); err != nil {
logger.Log(logger.LevelWarning, "server", "in provider `%s', %s", prov.Name, err)
logger.Log(logger.LevelWarning, "server", "discarding provider `%s'", prov.Name)
continue
}
// Add worker into pool if initialization went fine
server.providerWorkers.Add(providerWorker)
providerWorker.SendEvent(eventRun, true, nil)
logger.Log(logger.LevelDebug, "server", "declared provider `%s'", prov.Name)
}
return nil
}
示例2: workerCatalogRun
func workerCatalogRun(w *worker.Worker, args ...interface{}) {
var serverCatalog = w.Props[0].(*catalog.Catalog)
defer w.Shutdown()
logger.Log(logger.LevelDebug, "catalogWorker", "starting")
w.State = worker.JobStarted
for {
select {
case cmd := <-w.ReceiveJobSignals():
switch cmd {
case jobSignalShutdown:
logger.Log(logger.LevelInfo, "catalogWorker", "received shutdown command, stopping job")
w.State = worker.JobStopped
return
default:
logger.Log(logger.LevelNotice, "catalogWorker", "received unknown command, ignoring")
}
case record := <-serverCatalog.RecordChan:
serverCatalog.Insert(record)
}
}
}
示例3: Stop
// Stop stops the server.
func (server *Server) Stop() {
if server.stopping {
return
}
logger.Log(logger.LevelNotice, "server", "shutting down server")
server.stopping = true
// Shutdown serve worker
if err := server.serveWorker.SendEvent(eventShutdown, false, nil); err != nil {
logger.Log(logger.LevelWarning, "server", "serve worker did not shut down successfully: %s", err)
}
// Shutdown running provider workers
server.stopProviderWorkers()
// Shutdown catalog worker
if err := server.catalogWorker.SendEvent(eventShutdown, false, nil); err != nil {
logger.Log(logger.LevelWarning, "server", "catalog worker did not shut down successfully: %s", err)
}
server.Catalog.Close()
// Remove pid file
if server.Config.PidFile != "" {
logger.Log(logger.LevelDebug, "server", "removing `%s' pid file", server.Config.PidFile)
os.Remove(server.Config.PidFile)
}
server.wg.Done()
}
示例4: Refresh
// Refresh triggers a full connector data update.
func (connector *InfluxDBConnector) Refresh(originName string, outputChan chan<- *catalog.Record) error {
seriesList, err := connector.client.Query("select * from /.*/ limit 1")
if err != nil {
return fmt.Errorf("influxdb[%s]: unable to fetch series list: %s", connector.name, err)
}
for _, series := range seriesList {
var seriesName, sourceName, metricName string
seriesName = series.GetName()
seriesPoints := series.GetPoints()
if len(seriesPoints) == 0 {
logger.Log(logger.LevelInfo,
"connector",
"influxdb[%s]: series `%s' does not return sample data, ignoring",
connector.name,
seriesName,
)
continue
}
for columnIndex, columnName := range series.GetColumns() {
if columnName == "time" || columnName == "sequence_number" {
continue
} else if _, ok := seriesPoints[0][columnIndex].(float64); !ok {
continue
}
seriesMatch, err := matchSeriesPattern(connector.re, seriesName+"."+columnName)
if err != nil {
logger.Log(logger.LevelInfo,
"connector",
"influxdb[%s]: series `%s' does not match pattern, ignoring",
connector.name,
seriesName,
)
continue
}
sourceName, metricName = seriesMatch[0], seriesMatch[1]
if _, ok := connector.series[sourceName]; !ok {
connector.series[sourceName] = make(map[string][2]string)
}
connector.series[sourceName][metricName] = [2]string{seriesName, columnName}
outputChan <- &catalog.Record{
Origin: originName,
Source: sourceName,
Metric: metricName,
Connector: connector,
}
}
}
return nil
}
示例5: workerServeRun
func workerServeRun(w *worker.Worker, args ...interface{}) {
var server = w.Props[0].(*Server)
defer w.Shutdown()
logger.Log(logger.LevelDebug, "serveWorker", "starting")
// Prepare router
router := NewRouter(server)
router.HandleFunc(urlStaticPath, server.serveStatic)
router.HandleFunc(urlCatalogPath, server.serveCatalog)
router.HandleFunc(urlLibraryPath, server.serveLibrary)
router.HandleFunc(urlAdminPath, server.serveAdmin)
router.HandleFunc(urlBrowsePath, server.serveBrowse)
router.HandleFunc(urlShowPath, server.serveShow)
router.HandleFunc(urlReloadPath, server.serveReload)
router.HandleFunc(urlStatsPath, server.serveStats)
router.HandleFunc("/", server.serveBrowse)
http.Handle("/", router)
// Start serving HTTP requests
listener, err := net.Listen("tcp", server.Config.BindAddr)
if err != nil {
w.ReturnErr(err)
return
}
logger.Log(logger.LevelInfo, "serveWorker", "listening on %s", server.Config.BindAddr)
go http.Serve(listener, nil)
for {
select {
case cmd := <-w.ReceiveJobSignals():
switch cmd {
case jobSignalShutdown:
logger.Log(logger.LevelInfo, "serveWorker", "received shutdown command, stopping job")
listener.Close()
logger.Log(logger.LevelInfo, "serveWorker", "server listener closed")
w.State = worker.JobStopped
return
default:
logger.Log(logger.LevelInfo, "serveWorker", "received unknown command, ignoring")
}
}
}
w.ReturnErr(nil)
}
示例6: expandGroup
func (library *Library) expandGroup(name string, groupType int, sourceName string) []string {
item, err := library.GetItemByName(name, groupType)
if err != nil {
logger.Log(logger.LevelError, "library", "expand group: unknown group `%s': %s", name, err)
return []string{}
}
// Parse group entries for patterns
group := item.(*Group)
result := []string{}
for _, entry := range group.Entries {
subResult := []string{}
if groupType == LibraryItemSourceGroup {
origin, err := library.Catalog.GetOrigin(entry.Origin)
if err != nil {
logger.Log(logger.LevelError, "library", "%s", err)
continue
}
for _, source := range origin.GetSources() {
if utils.FilterMatch(entry.Pattern, source.Name) {
subResult = append(subResult, source.Name)
}
}
} else {
source, err := library.Catalog.GetSource(entry.Origin, sourceName)
if err != nil {
logger.Log(logger.LevelError, "library", "%s", err)
continue
}
for _, metric := range source.GetMetrics() {
if utils.FilterMatch(entry.Pattern, metric.Name) {
subResult = append(subResult, metric.Name)
}
}
}
// Preserve manual ordering if grouped with `Single' matching type
if strings.HasPrefix(entry.Pattern, "glob:") || strings.HasPrefix(entry.Pattern, "regexp:") {
sort.Strings(subResult)
}
// Merge all group items subresults
result = append(result, subResult...)
}
return result
}
示例7: serveAdmin
func (server *Server) serveAdmin(writer http.ResponseWriter, request *http.Request) {
var err error
if request.Method != "GET" && request.Method != "HEAD" {
server.serveResponse(writer, nil, http.StatusMethodNotAllowed)
return
}
setHTTPCacheHeaders(writer)
if strings.HasPrefix(request.URL.Path, urlAdminPath+"sourcegroups/") ||
strings.HasPrefix(request.URL.Path, urlAdminPath+"metricgroups/") {
err = server.serveAdminGroup(writer, request)
} else if strings.HasPrefix(request.URL.Path, urlAdminPath+"graphs/") {
err = server.serveAdminGraph(writer, request)
} else if strings.HasPrefix(request.URL.Path, urlAdminPath+"collections/") {
err = server.serveAdminCollection(writer, request)
} else if request.URL.Path == urlAdminPath+"origins/" || request.URL.Path == urlAdminPath+"sources/" ||
request.URL.Path == urlAdminPath+"metrics/" {
err = server.serveAdminCatalog(writer, request)
} else if strings.HasPrefix(request.URL.Path, urlAdminPath+"scales/") {
err = server.serveAdminScale(writer, request)
} else if request.URL.Path == urlAdminPath {
err = server.serveAdminIndex(writer, request)
} else {
err = os.ErrNotExist
}
if os.IsNotExist(err) {
server.serveError(writer, http.StatusNotFound)
} else if err != nil {
logger.Log(logger.LevelError, "server", "%s", err)
server.serveError(writer, http.StatusInternalServerError)
}
}
示例8: workerProviderRefresh
func workerProviderRefresh(w *worker.Worker, args ...interface{}) {
var prov = w.Props[0].(*provider.Provider)
logger.Log(logger.LevelDebug, "provider", "%s: refresh", prov.Name)
w.SendJobSignal(jobSignalRefresh)
}
示例9: Insert
// Insert inserts a new record in the catalog.
func (catalog *Catalog) Insert(record *CatalogRecord) {
logger.Log(
logger.LevelDebug,
"catalog",
"appending metric `%s' to source `%s' via origin `%s'",
record.Metric,
record.Source,
record.Origin,
)
if _, ok := catalog.Origins[record.Origin]; !ok {
catalog.Origins[record.Origin] = NewOrigin(
record.Origin,
record.OriginalOrigin,
catalog,
)
}
if _, ok := catalog.Origins[record.Origin].Sources[record.Source]; !ok {
catalog.Origins[record.Origin].Sources[record.Source] = NewSource(
record.Source,
record.OriginalSource,
catalog.Origins[record.Origin],
)
}
if _, ok := catalog.Origins[record.Origin].Sources[record.Source].Metrics[record.Metric]; !ok {
catalog.Origins[record.Origin].Sources[record.Source].Metrics[record.Metric] = NewMetric(
record.Metric,
record.OriginalMetric,
catalog.Origins[record.Origin].Sources[record.Source],
record.Connector,
)
}
}
示例10: workerProviderShutdown
func workerProviderShutdown(w *worker.Worker, args ...interface{}) {
var prov = w.Props[0].(*provider.Provider)
logger.Log(logger.LevelDebug, "provider", "%s: shutdown", prov.Name)
w.SendJobSignal(jobSignalShutdown)
}
示例11: compileAggregatorPatterns
func compileAggregatorPatterns(aggregators interface{}, connector string) []metricAggregator {
var (
re *regexp.Regexp
err error
)
if aggregators == nil {
return nil
}
list := aggregators.([]interface{})
out := make([]metricAggregator, 0)
for _, a := range list {
aggregator := a.(map[string]interface{})
if re, err = regexp.Compile(aggregator["metric"].(string)); err != nil {
logger.Log(logger.LevelWarning, "connector", "kairosdb[%s]: can't compile `%s', skipping", connector,
aggregator["metric"].(string))
continue
}
out = append(out, metricAggregator{
pattern: aggregator["metric"].(string),
re: re,
hook: aggregator["aggregator"],
})
}
return out
}
示例12: workerServeShutdown
func workerServeShutdown(w *worker.Worker, args ...interface{}) {
logger.Log(logger.LevelDebug, "serveWorker", "shutdown")
w.SendJobSignal(jobSignalShutdown)
w.ReturnErr(nil)
}
示例13: serveGraphList
func (server *Server) serveGraphList(writer http.ResponseWriter, request *http.Request) {
var offset, limit int
if response, status := server.parseListRequest(writer, request, &offset, &limit); status != http.StatusOK {
server.serveResponse(writer, response, status)
return
}
graphSet := set.New(set.ThreadSafe)
// Filter on collection if any
if request.FormValue("collection") != "" {
item, err := server.Library.GetItem(request.FormValue("collection"), library.LibraryItemCollection)
if os.IsNotExist(err) {
server.serveResponse(writer, serverResponse{mesgResourceNotFound}, http.StatusNotFound)
return
} else if err != nil {
logger.Log(logger.LevelError, "server", "%s", err)
server.serveResponse(writer, serverResponse{mesgUnhandledError}, http.StatusInternalServerError)
return
}
collection := item.(*library.Collection)
for _, graph := range collection.Entries {
graphSet.Add(graph.ID)
}
}
// Fill graphs list
items := make(ItemListResponse, 0)
for _, graph := range server.Library.Graphs {
if !graphSet.IsEmpty() && !graphSet.Has(graph.ID) {
continue
}
if request.FormValue("filter") != "" && !utils.FilterMatch(request.FormValue("filter"), graph.Name) {
continue
}
items = append(items, &ItemResponse{
ID: graph.ID,
Name: graph.Name,
Description: graph.Description,
Modified: graph.Modified.Format(time.RFC3339),
})
}
response := &listResponse{
list: items,
offset: offset,
limit: limit,
}
server.applyResponseLimit(writer, request, response)
server.serveResponse(writer, response.list, http.StatusOK)
}
示例14: workerProviderRun
func workerProviderRun(w *worker.Worker, args ...interface{}) {
var (
prov = w.Props[0].(*provider.Provider)
timeTicker *time.Ticker
timeChan <-chan time.Time
)
defer func() { w.State = worker.JobStopped }()
defer w.Shutdown()
logger.Log(logger.LevelDebug, "provider", "%s: starting", prov.Name)
// If provider `refresh_interval` has been configured, set up a time ticker
if prov.Config.RefreshInterval > 0 {
timeTicker = time.NewTicker(time.Duration(prov.Config.RefreshInterval) * time.Second)
timeChan = timeTicker.C
}
for {
select {
case _ = <-timeChan:
logger.Log(logger.LevelDebug, "provider", "%s: performing refresh from connector", prov.Name)
if err := prov.Connector.Refresh(prov.Name, prov.Filters.Input); err != nil {
logger.Log(logger.LevelError, "provider", "%s: unable to refresh: %s", prov.Name, err)
continue
}
prov.LastRefresh = time.Now()
case cmd := <-w.ReceiveJobSignals():
switch cmd {
case jobSignalRefresh:
logger.Log(logger.LevelInfo, "provider", "%s: received refresh command", prov.Name)
if err := prov.Connector.Refresh(prov.Name, prov.Filters.Input); err != nil {
logger.Log(logger.LevelError, "provider", "%s: unable to refresh: %s", prov.Name, err)
continue
}
prov.LastRefresh = time.Now()
case jobSignalShutdown:
logger.Log(logger.LevelInfo, "provider", "%s: received shutdown command, stopping job", prov.Name)
w.State = worker.JobStopped
if timeTicker != nil {
// Stop refresh time ticker
timeTicker.Stop()
}
return
default:
logger.Log(logger.LevelNotice, "provider", "%s: received unknown command, ignoring", prov.Name)
}
}
}
}
示例15: Reload
// Reload reloads the configuration and refreshes both catalog and library.
func (server *Server) Reload(config bool) error {
logger.Log(logger.LevelNotice, "server", "reloading")
server.loading = true
if config {
if err := server.Config.Reload(); err != nil {
logger.Log(logger.LevelError, "server", "unable to reload configuration: %s", err)
return err
}
}
server.providerWorkers.Broadcast(eventCatalogRefresh, nil)
server.Library.Refresh()
server.loading = false
return nil
}