no more logger

exchange/exchange.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"local/logger"
 	"local/rssmon2/monitor"
 	"local/rssmon2/rss"
 	"local/rssmon2/server"
@@ -68,12 +67,12 @@ func (ex *Exchange) LoadDB() error {
 func (ex *Exchange) NewFeed(url, itemFilter, contentFilter string, tags []string, interval time.Duration) {
 	feed, err := rss.New(url, itemFilter, contentFilter, tags, interval)
 	if err != nil {
-		logger.Logf("can't create new RSS %q: %v", url, err)
+		log.Printf("can't create new RSS %q: %v", url, err)
 		return
 	}
 	ex.allFeeds[url] = feed
 	if err := ex.Mon.Submit(url, feed.Interval); err != nil {
-		logger.Logf("Cannot accept new feed %q: %v", url, err)
+		log.Printf("Cannot accept new feed %q: %v", url, err)
 	}
 }
 
@@ -191,48 +190,48 @@ func (ex *Exchange) UpdateFeed(url string) {
 	if !ok {
 		f, err := rss.New(url, "", "", nil, time.Minute)
 		if err != nil {
-			logger.Logf("cannot identify unknown feed triggered in monitor: %q: %v", url, err)
+			log.Printf("cannot identify unknown feed triggered in monitor: %q: %v", url, err)
 			return
 		}
 		b, err := ex.SClient.Get(nsForFeeds, f.ID())
 		if err != nil {
-			logger.Logf("cannot get unknown feed triggered in monitor: %q: %v", url, err)
+			log.Printf("cannot get unknown feed triggered in monitor: %q: %v", url, err)
 			return
 		}
 		feed, err = rss.Deserialize(b)
 		if err != nil {
-			logger.Logf("cannot deserialize feed triggered in monitor: %q: %v", url, err)
+			log.Printf("cannot deserialize feed triggered in monitor: %q: %v", url, err)
 			return
 		}
 	}
 	items, err := ex.allFeeds[url].Update()
 	if err != nil {
-		logger.Logf("can't update old RSS %q: %v", url, err)
+		log.Printf("can't update old RSS %q: %v", url, err)
 		return
 	}
 	b, err := feed.Serialize()
 	if err != nil {
-		logger.Logf("can't serialize to save RSS %q: %v", url, err)
+		log.Printf("can't serialize to save RSS %q: %v", url, err)
 		return
 	}
 	if err := ex.SClient.Set(nsForFeeds, feed.ID(), b); err != nil {
-		logger.Logf("can't save RSS %q.%q: %v", nsForFeeds, feed.ID(), err)
+		log.Printf("can't save RSS %q.%q: %v", nsForFeeds, feed.ID(), err)
 		return
 	}
-	logger.Log("Saved feed", feed)
+	log.Print("Saved feed", feed)
 	for i := range items {
 		b, err := items[i].Serialize()
 		if err != nil {
-			logger.Logf("can't save rss item %q.%q: %v", url, items[i].Link, err)
+			log.Printf("can't save rss item %q.%q: %v", url, items[i].Link, err)
 			return
 		}
 		if err := ex.SClient.Set(feed.ID(), items[i].ID(), b); err != nil {
-			logger.Logf("can't save rss item %q.%q: %v", feed.ID(), items[i].ID(), err)
+			log.Printf("can't save rss item %q.%q: %v", feed.ID(), items[i].ID(), err)
 			return
 		}
-		//logger.Log("Saved feed item", feed.ID(), items[i].ID(), items[i])
+		//log.Print("Saved feed item", feed.ID(), items[i].ID(), items[i])
 	}
-	logger.Logf("Saved %d feed items for %s", len(items), feed.Title)
+	log.Printf("Saved %d feed items for %s", len(items), feed.Title)
 	go ex.handlerByTag(feed.Tags, items)
 }
 
@@ -289,13 +288,13 @@ func (ex *Exchange) handlerPodcast(item *rss.Item) {
 func (ex *Exchange) handlerTorrent(item *rss.Item) {
 	magnet := regexp.MustCompile("magnet:.xt[^ $]*")
 	if !magnet.MatchString(item.Content) {
-		logger.Log("no magnet link: ", item.Content)
+		log.Print("no magnet link: ", item.Content)
 	}
 	match := magnet.FindString(item.Content)
 
 	resp, err := http.Get(ex.toraddr)
 	if err != nil {
-		logger.Logf("cannot get session id at %v: %v", ex.toraddr, err)
+		log.Printf("cannot get session id at %v: %v", ex.toraddr, err)
 		return
 	}
 	sessionID := resp.Header.Get("X-Transmission-Session-Id")
@@ -307,28 +306,28 @@ func (ex *Exchange) handlerTorrent(item *rss.Item) {
 		},
 	})
 	if err != nil {
-		logger.Log("cannot build request body: %v", err)
+		log.Print("cannot build request body: %v", err)
 		return
 	}
 	req, err := http.NewRequest("POST", ex.toraddr, bytes.NewBuffer(requestBody))
 	if err != nil {
-		logger.Log("cannot POST request: %v", err)
+		log.Print("cannot POST request: %v", err)
 		return
 	}
 	req.Header.Add("X-Transmission-Session-Id", sessionID)
 	resp, err = (&http.Client{}).Do(req)
 	if err != nil {
-		logger.Log("failed POST: %v", err)
+		log.Print("failed POST: %v", err)
 		return
 	}
 
 	var out map[string]interface{}
 	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
-		logger.Log("cannot decode response: %v", err)
+		log.Print("cannot decode response: %v", err)
 		return
 	}
 
 	if v, ok := out["result"]; !ok || v != "success" {
-		logger.Logf("failed magnet submission for feed item %v: %v", item.Name, v)
+		log.Printf("failed magnet submission for feed item %v: %v", item.Name, v)
 	}
 }

main.go

@@ -1,12 +1,12 @@
 package main
 
 import (
-	"local/logger"
 	"local/rssmon2/config"
 	"local/rssmon2/exchange"
 	"local/rssmon2/monitor"
 	"local/rssmon2/server"
 	"local/rssmon2/store"
+	"log"
 )
 
 func main() {
@@ -52,7 +52,7 @@ func core() {
 		panic(err)
 	}
 
-	logger.Log("Starting with", config)
+	log.Print("Starting with", config)
 	if err := srv.Serve(); err != nil {
 		panic(err)
 	}

monitor/monitor.go

@@ -2,7 +2,7 @@ package monitor
 
 import (
 	"errors"
-	"local/logger"
+	"log"
 	"time"
 
 	"github.com/golang-collections/go-datastructures/queue"
@@ -59,29 +59,29 @@ func (monitor *Monitor) loop() error {
 			}
 			var err error
 			if nextEvent, err = nextEventTime(queue); err != nil {
-				logger.Log("no next event time", err)
+				log.Print("no next event time", err)
 				nextEvent = time.Now().Add(time.Minute * 60)
 				continue
 			}
 		case <-time.After(nextEvent.Sub(time.Now())):
 			items, err := queue.Get(1)
 			if err != nil {
-				logger.Fatal("can't get item")
+				log.Fatal("can't get item")
 			}
 			if len(items) == 0 {
-				logger.Log("no items in queue")
+				log.Print("no items in queue")
 				nextEvent = time.Now().Add(time.Minute * 60)
 				continue
 			}
 			item, ok := items[0].(*Item)
 			if !ok {
-				logger.Fatal("queue contains illegal item")
+				log.Fatal("queue contains illegal item")
 			}
 			go monitor.trigger(item.URL)
 			item.increment()
 			queue.Put(item)
 			if nextEvent, err = nextEventTime(queue); err != nil {
-				logger.Log("no next event time", err)
+				log.Print("no next event time", err)
 				nextEvent = time.Now().Add(time.Minute * 60)
 				continue
 			}

rss/feed.go

@@ -5,7 +5,7 @@ import (
 	"encoding/gob"
 	"fmt"
 	"io/ioutil"
-	"local/logger"
+	"log"
 	"net/http"
 	"regexp"
 	"strings"
@@ -118,19 +118,19 @@ func (feed *Feed) appendNewItems(items []*gofeed.Item) ([]*Item, time.Time, erro
 	for i := range items {
 		t := gofeedItemTS(items[i])
 		if *t != (time.Time{}) && t.Before(feed.Updated) {
-			logger.Logf("\tnot adding %v because its timestamp before %v", items[i].Link, feed.Updated)
+			log.Printf("\tnot adding %v because its timestamp before %v", items[i].Link, feed.Updated)
 			continue
 		}
 		if t.After(latest) {
 			latest = *t
 		}
 		if ok, _ := regexp.MatchString(feed.ItemFilter, items[i].Title); !ok {
-			logger.Logf("\tnot adding %v because its title doesnt match item filter %v", items[i].Link, feed.ItemFilter)
+			log.Printf("\tnot adding %v because its title doesnt match item filter %v", items[i].Link, feed.ItemFilter)
 			continue
 		}
 		item := FromGofeedItem(items[i], feed.ContentFilter)
 		newitems = append(newitems, item)
 	}
-	logger.Logf("\tnew latest is %v", latest)
+	log.Printf("\tnew latest is %v", latest)
 	return newitems, latest, nil
 }

server/server.go

@@ -3,7 +3,7 @@ package server
 import (
 	"encoding/json"
 	"fmt"
-	"local/logger"
+	"log"
 	"net/http"
 	"net/url"
 	"os"
@@ -166,7 +166,7 @@ func (s *Server) getFeedTag(w http.ResponseWriter, r *http.Request) {
 	}
 	feedBody, err := s.getFeedTagHandler(url)
 	if err != nil {
-		logger.Logf("cannot get feed tag %s: %v", url, err)
+		log.Printf("cannot get feed tag %s: %v", url, err)
 		s.mybad(w, r)
 		return
 	}
@@ -181,7 +181,7 @@ func (s *Server) getFeedItem(w http.ResponseWriter, r *http.Request) {
 	}
 	feedBody, err := s.getFeedItemHandler(url)
 	if err != nil {
-		logger.Logf("cannot get feed item %s: %v", url, err)
+		log.Printf("cannot get feed item %s: %v", url, err)
 		s.mybad(w, r)
 		return
 	}
@@ -202,7 +202,7 @@ func (s *Server) getFeed(w http.ResponseWriter, r *http.Request) {
 	}
 	feedBody, err := s.getFeedHandler(url, limit)
 	if err != nil {
-		logger.Logf("cannot get feed %s: %v", url, err)
+		log.Printf("cannot get feed %s: %v", url, err)
 		s.mybad(w, r)
 		return
 	}