Golang tracelog.Error函數代碼示例

func HomeHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json; charset=UTF-8")

	vars := mux.Vars(r)
	brand := vars["brand"]
	postalCode := vars["postalCode"]

	tracelog.Trace("Brand Value", "main", "Brand is %s", brand)
	tracelog.Trace("Postal Code", "main", "PostalCode is %s", postalCode)

	// now call the Edmunds API
	dealers, dealerErr := DealersAroundZipCode(postalCode, 100, brand, true)
	if dealerErr != nil {
		ReturnErrorToClient(w, dealerErr, "Error calling dealer service with zip code "+postalCode)
		tracelog.Error(dealerErr, "DealersAroundZipCode failed", "HomeHandler")
		return
	}

	w.WriteHeader(http.StatusOK)
	var err error
	if err = json.NewEncoder(w).Encode(dealers); err != nil {
		tracelog.Error(err, "JSON encoding failed", "HomeHandler")
		panic(err)
	}
}

func ReturnErrorToClient(w http.ResponseWriter, err error, msg string) {
	tracelog.Error(err, msg, "ReturnErrorToClient")

	w.WriteHeader(http.StatusBadRequest)

	if encodeError := json.NewEncoder(w).Encode(JsonError{Code: http.StatusBadRequest, Error: msg}); encodeError != nil {
		tracelog.Error(encodeError, "JSON encoding failed", "ReturnErrorToClient")
		panic("JSON encoding failed")
	}
}

func AddBook(jsonStr []byte) bool {
	o := orm.NewOrm()
	var book Book
	err := json.Unmarshal(jsonStr, &book)
	if err != nil {
		tracelog.Error(err, "Failed to insert json", "model.AddBook")
		return false
	}
	_, err = o.Insert(&book)
	if err != nil {
		tracelog.Error(err, "Failed to insert book", "model.AddBook")
		return false
	}
	return true
}

func UpdateLibrary(jsonStr []byte) bool {
	o := orm.NewOrm()
	var lib Library
	err := json.Unmarshal(jsonStr, &lib)
	if err != nil {
		tracelog.Error(err, "Failed to parse json", "model.UpdateLibrary")
		return false
	}
	_, err = o.Update(&lib)
	if err != nil {
		tracelog.Error(err, "Failed to update lib", "model.UpdateLibrary")
		return false
	}
	return true
}

func AddLibrary(jsonStr []byte) bool {
	o := orm.NewOrm()
	var lib Library
	err := json.Unmarshal(jsonStr, &lib)
	if err != nil {
		tracelog.Error(err, "Failed to insert json", "model.AddLibrary")
		return false
	}
	_, err = o.Insert(&lib)
	if err != nil {
		tracelog.Error(err, "Failed to insert lib", "model.AddLibrary")
		return false
	}
	return true
}

func UpdateBook(jsonStr []byte) bool {
	o := orm.NewOrm()
	var book Book
	err := json.Unmarshal(jsonStr, &book)
	if err != nil {
		tracelog.Error(err, "Failed to parse json", "model.UpdateBook")
		return false
	}
	_, err = o.Update(&book)
	if err != nil {
		tracelog.Error(err, "Failed to update book", "model.UpdateBook")
		return false
	}
	return true
}

func DeleteLibrary(libId int64) bool {
	o := orm.NewOrm()
	if _, err := o.Delete(&Library{Id: libId}); err == nil {
		tracelog.Error(err, "Failed to delete lib", "model.DeleteLibrary")
		return false
	}
	return true
}

func DeleteBook(bookId int64) bool {
	o := orm.NewOrm()
	if _, err := o.Delete(&Book{Id: bookId}); err == nil {
		tracelog.Error(err, "Failed to query", "model.DeleteBook")
		return false
	}
	return true
}

// Prepare is called before any controller.
func (service *Service) Prepare() (err error) {
	service.MongoSession, err = mongo.CopyMonotonicSession(service.UserID)
	if err != nil {
		log.Error(err, service.UserID, "Service.Prepare")
		return err
	}

	return err
}

func GetBook(bookId int64) (*Book, error) {
	o := orm.NewOrm()
	book := Book{Id: bookId}
	err := o.Read(&book)
	if err != nil {
		tracelog.Error(err, "Failed to query", "model.GetBook")
	}
	return &book, err
}

func AddBookInLibrary(libraryId int64, bookId int64) bool {
	o := orm.NewOrm()
	_, err := o.Raw(`
		INSERT INTO book_library(book_id, library_id) VALUES(?, ?)`, bookId, libraryId).Exec()
	if err != nil {
		tracelog.Error(err, "Failed to query", "model.AddBookInLibrary")
		return false
	}
	return true
}

func (c *LibraryController) listBooksInLibrary() {
	libId, _ := strconv.ParseInt(c.Ctx.Input.Param(":libId"), 10, 64)
	books, err := model.GetBooksInLibrary(libId)

	if err == orm.ErrNoRows {
		tracelog.Error(err, "No result found", "MainController")
	}
	c.Data["json"] = &books
	c.ServeJson()
}

func main() {
	tracelog.Start(tracelog.LevelTrace)
	//tracelog.Start(tracelog.LevelInfo)

	var port = os.Getenv("PORT")

	if port == "" {
		tracelog.Error(nil, "The PORT environment variable has not been set.", "main")
		os.Exit(1)
	}

	var myGasFeedBaseUrl = os.Getenv("MY_GAS_FEED_BASE_URL")
	if myGasFeedBaseUrl == "" {
		tracelog.Error(nil, "The MY_GAS_FEED_BASE_URL environment variable has not been set.", "main")
	}
	SetMyGasFeedBaseUrl(myGasFeedBaseUrl)

	var myGasFeedApiKey = os.Getenv("MY_GAS_FEED_API_KEY")
	if myGasFeedApiKey == "" {
		tracelog.Error(nil, "The MY_GAS_FEED_API_KEY environment variable has not been set.", "main")
	}
	SetMyGasFeedApiKey(myGasFeedApiKey)

	tracelog.Info("Started", "main", "Gas Price Service is starting and listening on port %s", port)

	router := mux.NewRouter()
	for _, route := range routes {
		var handler http.Handler

		handler = route.HandlerFunc
		handler = Logger(handler, route.Name)

		router.Methods(route.Method).Path(route.Pattern).Name(route.Name).Handler(handler)
	}

	err := http.ListenAndServe(":"+port, router)
	if err != nil {
		tracelog.Error(err, "An error occurred while attempting to listen and serve", "main")
	}

	tracelog.Info("Stopped", "main", "Gas Price Service has been terminated")
	tracelog.Stop()
}

func (p *MgoCtx) login(db *mgo.Database) bool {
	if p.cfg.Pwd == "" {
		return true
	}
	if err := db.Login(p.cfg.User, p.cfg.Pwd); err != nil {
		log.Error(err, "Login", "mdb.Startup")
		return false
	}
	return true
}

func GetAllBooks() (*[]Book, error) {
	var rows []Book
	o := orm.NewOrm()
	_, err := o.Raw(`
		SELECT b.id, b.name, b.author 
		FROM book b`).QueryRows(&rows)
	if err != nil {
		tracelog.Error(err, "Failed to query", "model.GetAllBooks")
	}
	return &rows, err
}