STRLCPY/gophish

■ ■ ■ ■ ■ ■

auth/auth.go

		skipped 9 lines
10	10		"crypto/rand"
11	11
12	12		ctx "github.com/gophish/gophish/context"
	13	+	log "github.com/gophish/gophish/logger"
13	14		"github.com/gophish/gophish/models"
14	15		"github.com/gorilla/securecookie"
15	16		"github.com/gorilla/sessions"
		skipped 57 lines
73	74
74	75		// If we have an error which is not simply indicating that no user was found, report it
75	76		if err != nil && err != gorm.ErrRecordNotFound {
76		-	fmt.Println(err)
	77	+	log.Warn(err)
77	78		return false, err
78	79		}
79	80
		skipped 61 lines

■ ■ ■ ■ ■ ■

config/config.go

		skipped 1 lines
2	2
3	3		import (
4	4		"encoding/json"
5		-	"fmt"
6	5		"io/ioutil"
	6	+
	7	+	log "github.com/gophish/gophish/logger"
7	8		)
8	9
9	10		// AdminServer represents the Admin server configuration details
		skipped 33 lines
43	44		// Get the config file
44	45		configFile, err := ioutil.ReadFile(filepath)
45	46		if err != nil {
46		-	fmt.Printf("File error: %v\n", err)
	47	+	log.Errorf("File error: %v\n", err)
47	48		}
48	49		json.Unmarshal(configFile, &Conf)
49	50
		skipped 6 lines

■ ■ ■ ■ ■ ■

controllers/api.go

		skipped 14 lines
15	15		"github.com/PuerkitoBio/goquery"
16	16		"github.com/gophish/gophish/auth"
17	17		ctx "github.com/gophish/gophish/context"
	18	+	log "github.com/gophish/gophish/logger"
18	19		"github.com/gophish/gophish/models"
19	20		"github.com/gophish/gophish/util"
20	21		"github.com/gophish/gophish/worker"
21	22		"github.com/gorilla/mux"
22	23		"github.com/jinzhu/gorm"
23	24		"github.com/jordan-wright/email"
	25	+	"github.com/sirupsen/logrus"
24	26		)
25	27
26	28		// Worker is the worker that processes phishing events and updates campaigns.
		skipped 11 lines
38	40		templates := template.New("template")
39	41		_, err := templates.ParseFiles("templates/docs.html")
40	42		if err != nil {
41		-	Logger.Println(err)
	43	+	log.Error(err)
42	44		}
43	45		template.Must(templates, err).ExecuteTemplate(w, "base", nil)
44	46		}
		skipped 21 lines
66	68		case r.Method == "GET":
67	69		cs, err := models.GetCampaigns(ctx.Get(r, "user_id").(int64))
68	70		if err != nil {
69		-	Logger.Println(err)
	71	+	log.Error(err)
70	72		}
71	73		JSONResponse(w, cs, http.StatusOK)
72	74		//POST: Create a new campaign and return it as JSON
		skipped 25 lines
98	100		case r.Method == "GET":
99	101		cs, err := models.GetCampaignSummaries(ctx.Get(r, "user_id").(int64))
100	102		if err != nil {
101		-	Logger.Println(err)
	103	+	log.Error(err)
102	104		JSONResponse(w, models.Response{Success: false, Message: err.Error()}, http.StatusInternalServerError)
103	105		return
104	106		}
		skipped 8 lines
113	115		id, _ := strconv.ParseInt(vars["id"], 0, 64)
114	116		c, err := models.GetCampaign(id, ctx.Get(r, "user_id").(int64))
115	117		if err != nil {
116		-	Logger.Println(err)
	118	+	log.Error(err)
117	119		JSONResponse(w, models.Response{Success: false, Message: "Campaign not found"}, http.StatusNotFound)
118	120		return
119	121		}
		skipped 17 lines
137	139		id, _ := strconv.ParseInt(vars["id"], 0, 64)
138	140		cr, err := models.GetCampaignResults(id, ctx.Get(r, "user_id").(int64))
139	141		if err != nil {
140		-	Logger.Println(err)
	142	+	log.Error(err)
141	143		JSONResponse(w, models.Response{Success: false, Message: "Campaign not found"}, http.StatusNotFound)
142	144		return
143	145		}
		skipped 16 lines
160	162		} else {
161	163		JSONResponse(w, models.Response{Success: false, Message: err.Error()}, http.StatusInternalServerError)
162	164		}
163		-	Logger.Println(err)
	165	+	log.Error(err)
164	166		return
165	167		}
166	168		JSONResponse(w, cs, http.StatusOK)
		skipped 58 lines
225	227		case r.Method == "GET":
226	228		gs, err := models.GetGroupSummaries(ctx.Get(r, "user_id").(int64))
227	229		if err != nil {
228		-	Logger.Println(err)
	230	+	log.Error(err)
229	231		JSONResponse(w, models.Response{Success: false, Message: err.Error()}, http.StatusInternalServerError)
230	232		return
231	233		}
		skipped 61 lines
293	295		case r.Method == "GET":
294	296		ts, err := models.GetTemplates(ctx.Get(r, "user_id").(int64))
295	297		if err != nil {
296		-	Logger.Println(err)
	298	+	log.Error(err)
297	299		}
298	300		JSONResponse(w, ts, http.StatusOK)
299	301		//POST: Create a new template and return it as JSON
		skipped 23 lines
323	325		}
324	326		if err != nil {
325	327		JSONResponse(w, models.Response{Success: false, Message: "Error inserting template into database"}, http.StatusInternalServerError)
326		-	Logger.Println(err)
	328	+	log.Error(err)
327	329		return
328	330		}
329	331		JSONResponse(w, t, http.StatusCreated)
		skipped 23 lines
353	355		t = models.Template{}
354	356		err = json.NewDecoder(r.Body).Decode(&t)
355	357		if err != nil {
356		-	Logger.Println(err)
	358	+	log.Error(err)
357	359		}
358	360		if t.Id != id {
359	361		JSONResponse(w, models.Response{Success: false, Message: "Error: /:id and template_id mismatch"}, http.StatusBadRequest)
		skipped 16 lines
376	378		case r.Method == "GET":
377	379		ps, err := models.GetPages(ctx.Get(r, "user_id").(int64))
378	380		if err != nil {
379		-	Logger.Println(err)
	381	+	log.Error(err)
380	382		}
381	383		JSONResponse(w, ps, http.StatusOK)
382	384		//POST: Create a new page and return it as JSON
		skipped 9 lines
392	394		_, err = models.GetPageByName(p.Name, ctx.Get(r, "user_id").(int64))
393	395		if err != gorm.ErrRecordNotFound {
394	396		JSONResponse(w, models.Response{Success: false, Message: "Page name already in use"}, http.StatusConflict)
395		-	Logger.Println(err)
	397	+	log.Error(err)
396	398		return
397	399		}
398	400		p.ModifiedDate = time.Now().UTC()
		skipped 31 lines
430	432		p = models.Page{}
431	433		err = json.NewDecoder(r.Body).Decode(&p)
432	434		if err != nil {
433		-	Logger.Println(err)
	435	+	log.Error(err)
434	436		}
435	437		if p.Id != id {
436	438		JSONResponse(w, models.Response{Success: false, Message: "/:id and /:page_id mismatch"}, http.StatusBadRequest)
		skipped 16 lines
453	455		case r.Method == "GET":
454	456		ss, err := models.GetSMTPs(ctx.Get(r, "user_id").(int64))
455	457		if err != nil {
456		-	Logger.Println(err)
	458	+	log.Error(err)
457	459		}
458	460		JSONResponse(w, ss, http.StatusOK)
459	461		//POST: Create a new SMTP and return it as JSON
		skipped 9 lines
469	471		_, err = models.GetSMTPByName(s.Name, ctx.Get(r, "user_id").(int64))
470	472		if err != gorm.ErrRecordNotFound {
471	473		JSONResponse(w, models.Response{Success: false, Message: "SMTP name already in use"}, http.StatusConflict)
472		-	Logger.Println(err)
	474	+	log.Error(err)
473	475		return
474	476		}
475	477		s.ModifiedDate = time.Now().UTC()
		skipped 31 lines
507	509		s = models.SMTP{}
508	510		err = json.NewDecoder(r.Body).Decode(&s)
509	511		if err != nil {
510		-	Logger.Println(err)
	512	+	log.Error(err)
511	513		}
512	514		if s.Id != id {
513	515		JSONResponse(w, models.Response{Success: false, Message: "/:id and /:smtp_id mismatch"}, http.StatusBadRequest)
		skipped 44 lines
558	560		}
559	561		e, err := email.NewEmailFromReader(strings.NewReader(ir.Content))
560	562		if err != nil {
561		-	Logger.Println(err)
	563	+	log.Error(err)
562	564		}
563	565		// If the user wants to convert links to point to
564	566		// the landing page, let's make it happen by changing up
		skipped 123 lines
688	690		// Get the Template requested by name
689	691		s.Template, err = models.GetTemplateByName(s.Template.Name, ctx.Get(r, "user_id").(int64))
690	692		if err == gorm.ErrRecordNotFound {
691		-	Logger.Printf("Error - Template %s does not exist", s.Template.Name)
	693	+	log.WithFields(logrus.Fields{
	694	+	"template": s.Template.Name,
	695	+	}).Error("Template does not exist")
692	696		JSONResponse(w, models.Response{Success: false, Message: models.ErrTemplateNotFound.Error()}, http.StatusBadRequest)
693	697		return
694	698		} else if err != nil {
695		-	Logger.Println(err)
	699	+	log.Error(err)
696	700		JSONResponse(w, models.Response{Success: false, Message: err.Error()}, http.StatusBadRequest)
697	701		return
698	702		}
		skipped 6 lines
705	709		// If the Sending Profile doesn't exist, let's err on the side
706	710		// of caution and assume that the validation failure was more important.
707	711		if lookupErr != nil {
708		-	Logger.Println(err)
	712	+	log.Error(err)
709	713		JSONResponse(w, models.Response{Success: false, Message: err.Error()}, http.StatusBadRequest)
710	714		return
711	715		}
		skipped 16 lines
728	732		dj, err := json.MarshalIndent(d, "", " ")
729	733		if err != nil {
730	734		http.Error(w, "Error creating JSON response", http.StatusInternalServerError)
731		-	Logger.Println(err)
	735	+	log.Error(err)
732	736		}
733	737		w.Header().Set("Content-Type", "application/json")
734	738		w.WriteHeader(c)
		skipped 25 lines

■ ■ ■ ■ ■ ■

controllers/phish.go

		skipped 12 lines
13	13		"strings"
14	14
15	15		ctx "github.com/gophish/gophish/context"
	16	+	log "github.com/gophish/gophish/logger"
16	17		"github.com/gophish/gophish/models"
17	18		"github.com/gorilla/mux"
18	19		)
		skipped 32 lines
51	52		if err != nil {
52	53		// Log the error if it wasn't something we can safely ignore
53	54		if err != ErrInvalidRequest && err != ErrCampaignComplete {
54		-	Logger.Println(err)
	55	+	log.Error(err)
55	56		}
56	57		http.NotFound(w, r)
57	58		return
		skipped 10 lines
68	69		}
69	70		err = rs.UpdateStatus(models.EVENT_OPENED)
70	71		if err != nil {
71		-	Logger.Println(err)
	72	+	log.Error(err)
72	73		}
73	74		http.ServeFile(w, r, "static/images/pixel.png")
74	75		}
		skipped 4 lines
79	80		if err != nil {
80	81		// Log the error if it wasn't something we can safely ignore
81	82		if err != ErrInvalidRequest && err != ErrCampaignComplete {
82		-	Logger.Println(err)
	83	+	log.Error(err)
83	84		}
84	85		http.NotFound(w, r)
85	86		return
		skipped 5 lines
91	92
92	93		err = rs.UpdateReported(true)
93	94		if err != nil {
94		-	Logger.Println(err)
	95	+	log.Error(err)
95	96		}
96	97		w.WriteHeader(http.StatusNoContent)
97	98		}
		skipped 5 lines
103	104		if err != nil {
104	105		// Log the error if it wasn't something we can safely ignore
105	106		if err != ErrInvalidRequest && err != ErrCampaignComplete {
106		-	Logger.Println(err)
	107	+	log.Error(err)
107	108		}
108	109		http.NotFound(w, r)
109	110		return
		skipped 3 lines
113	114		rj := ctx.Get(r, "details").([]byte)
114	115		p, err := models.GetPage(c.PageId, c.UserId)
115	116		if err != nil {
116		-	Logger.Println(err)
	117	+	log.Error(err)
117	118		http.NotFound(w, r)
118	119		return
119	120		}
		skipped 4 lines
124	125		}
125	126		err = c.AddEvent(models.Event{Email: rs.Email, Message: models.EVENT_CLICKED, Details: string(rj)})
126	127		if err != nil {
127		-	Logger.Println(err)
	128	+	log.Error(err)
128	129		}
129	130		case r.Method == "POST":
130	131		// If data was POST'ed, let's record it
		skipped 1 lines
132	133		// Store the data in an event
133	134		c.AddEvent(models.Event{Email: rs.Email, Message: models.EVENT_DATA_SUBMIT, Details: string(rj)})
134	135		if err != nil {
135		-	Logger.Println(err)
	136	+	log.Error(err)
136	137		}
137	138		// Redirect to the desired page
138	139		if p.RedirectURL != "" {
		skipped 4 lines
143	144		var htmlBuff bytes.Buffer
144	145		tmpl, err := template.New("html_template").Parse(p.HTML)
145	146		if err != nil {
146		-	Logger.Println(err)
	147	+	log.Error(err)
147	148		http.NotFound(w, r)
148	149		return
149	150		}
150	151		f, err := mail.ParseAddress(c.SMTP.FromAddress)
151	152		if err != nil {
152		-	Logger.Println(err)
	153	+	log.Error(err)
153	154		}
154	155		fn := f.Name
155	156		if fn == "" {
		skipped 16 lines
172	173		}
173	174		err = tmpl.Execute(&htmlBuff, rsf)
174	175		if err != nil {
175		-	Logger.Println(err)
	176	+	log.Error(err)
176	177		http.NotFound(w, r)
177	178		return
178	179		}
		skipped 9 lines
188	189		func setupContext(r http.Request) (error, http.Request) {
189	190		err := r.ParseForm()
190	191		if err != nil {
191		-	Logger.Println(err)
	192	+	log.Error(err)
192	193		return err, r
193	194		}
194	195		id := r.Form.Get(models.RecipientParameter)
		skipped 6 lines
201	202		}
202	203		c, err := models.GetCampaign(rs.CampaignId, rs.UserId)
203	204		if err != nil {
204		-	Logger.Println(err)
	205	+	log.Error(err)
205	206		return err, r
206	207		}
207	208		// Don't process events for completed campaigns
		skipped 2 lines
210	211		}
211	212		ip, _, err := net.SplitHostPort(r.RemoteAddr)
212	213		if err != nil {
213		-	Logger.Println(err)
	214	+	log.Error(err)
214	215		return err, r
215	216		}
216	217		// Respect X-Forwarded headers
		skipped 3 lines
220	221		// Handle post processing such as GeoIP
221	222		err = rs.UpdateGeo(ip)
222	223		if err != nil {
223		-	Logger.Println(err)
	224	+	log.Error(err)
224	225		}
225	226		d := eventDetails{
226	227		Payload: r.Form,
		skipped 12 lines

■ ■ ■ ■ ■ ■

controllers/route.go

		skipped 2 lines
3	3		import (
4	4		"fmt"
5	5		"html/template"
6		-	"log"
7	6		"net/http"
8	7		"net/url"
9		-	"os"
10	8
11	9		"github.com/gophish/gophish/auth"
12	10		"github.com/gophish/gophish/config"
13	11		ctx "github.com/gophish/gophish/context"
	12	+	log "github.com/gophish/gophish/logger"
14	13		mid "github.com/gophish/gophish/middleware"
15	14		"github.com/gophish/gophish/models"
16	15		"github.com/gorilla/csrf"
17	16		"github.com/gorilla/mux"
18	17		"github.com/gorilla/sessions"
19	18		)
20		-
21		-	// Logger is used to send logging messages to stdout.
22		-	var Logger = log.New(os.Stdout, " ", log.Ldate\|log.Ltime\|log.Lshortfile)
23	19
24	20		// CreateAdminRouter creates the routes for handling requests to the web interface.
25	21		// This function returns an http.Handler to be used in http.ListenAndServe().
		skipped 75 lines
101	97		templates := template.New("template")
102	98		_, err := templates.ParseFiles("templates/register.html", "templates/flashes.html")
103	99		if err != nil {
104		-	Logger.Println(err)
	100	+	log.Error(err)
105	101		}
106	102		template.Must(templates, err).ExecuteTemplate(w, "base", params)
107	103		case r.Method == "POST":
		skipped 8 lines
116	112		}
117	113		// Check the error
118	114		m := err.Error()
119		-	Logger.Println(err)
	115	+	log.Error(err)
120	116		Flash(w, r, "danger", m)
121	117		session.Save(r, w)
122	118		http.Redirect(w, r, "/register", 302)
		skipped 132 lines
255	251		templates := template.New("template")
256	252		_, err := templates.ParseFiles("templates/login.html", "templates/flashes.html")
257	253		if err != nil {
258		-	Logger.Println(err)
	254	+	log.Error(err)
259	255		}
260	256		template.Must(templates, err).ExecuteTemplate(w, "base", params)
261	257		case r.Method == "POST":
262	258		//Attempt to login
263	259		succ, u, err := auth.Login(r)
264	260		if err != nil {
265		-	Logger.Println(err)
	261	+	log.Error(err)
266	262		}
267	263		//If we've logged in, save the session and redirect to the dashboard
268	264		if succ {
		skipped 15 lines
284	280		templates := template.New("template")
285	281		_, err := templates.ParseFiles("templates/login.html", "templates/flashes.html")
286	282		if err != nil {
287		-	Logger.Println(err)
	283	+	log.Error(err)
288	284		}
289	285		w.Header().Set("Content-Type", "text/html; charset=utf-8")
290	286		w.WriteHeader(http.StatusUnauthorized)
		skipped 28 lines
319	315		return
320	316		}
321	317		if url, ok := vars["url"]; ok {
322		-	Logger.Println(url)
	318	+	log.Error(url)
323	319		}
324	320		http.Error(w, "No URL given.", http.StatusBadRequest)
325	321		}
		skipped 2 lines
328	324		templates := template.New("template")
329	325		_, err := templates.ParseFiles("templates/base.html", "templates/"+tmpl+".html", "templates/flashes.html")
330	326		if err != nil {
331		-	Logger.Println(err)
	327	+	log.Error(err)
332	328		}
333	329		return template.Must(templates, err)
334	330		}
		skipped 10 lines

■ ■ ■ ■ ■ ■

gophish.go

		skipped 28 lines
29	29		"compress/gzip"
30	30		"context"
31	31		"io/ioutil"
32		-	"log"
33	32		"net/http"
34	33		"os"
35	34		"sync"
		skipped 4 lines
40	39		"github.com/gophish/gophish/auth"
41	40		"github.com/gophish/gophish/config"
42	41		"github.com/gophish/gophish/controllers"
	42	+	log "github.com/gophish/gophish/logger"
43	43		"github.com/gophish/gophish/mailer"
44	44		"github.com/gophish/gophish/models"
45	45		"github.com/gophish/gophish/util"
		skipped 1 lines
47	47		)
48	48
49	49		var (
50		-	Logger = log.New(os.Stdout, " ", log.Ldate\|log.Ltime\|log.Lshortfile)
51		-
52	50		configPath = kingpin.Flag("config", "Location of config.json.").Default("./config.json").String()
53	51		disableMailer = kingpin.Flag("disable-mailer", "Disable the mailer (for use with multi-system deployments)").Bool()
54	52		)
55	53
56	54		func main() {
57	55		// Load the version
	56	+
58	57		version, err := ioutil.ReadFile("./VERSION")
59	58		if err != nil {
60		-	Logger.Fatalln(err)
	59	+	log.Fatal(err)
61	60		}
62	61		kingpin.Version(string(version))
63	62
		skipped 15 lines
79	78		// Setup the global variables and settings
80	79		err = models.Setup()
81	80		if err != nil {
82		-	Logger.Fatalln(err)
	81	+	log.Fatal(err)
83	82		}
84	83		// Unlock any maillogs that may have been locked for processing
85	84		// when Gophish was last shutdown.
86	85		err = models.UnlockAllMailLogs()
87	86		if err != nil {
88		-	Logger.Fatalln(err)
	87	+	log.Fatal(err)
89	88		}
90	89		wg := &sync.WaitGroup{}
91	90		wg.Add(1)
		skipped 6 lines
98	97		if config.Conf.AdminConf.UseTLS { // use TLS for Admin web server if available
99	98		err := util.CheckAndCreateSSL(config.Conf.AdminConf.CertPath, config.Conf.AdminConf.KeyPath)
100	99		if err != nil {
101		-	Logger.Fatal(err)
	100	+	log.Fatal(err)
102	101		}
103		-	Logger.Printf("Starting admin server at https://%s\n", config.Conf.AdminConf.ListenURL)
104		-	Logger.Fatal(http.ListenAndServeTLS(config.Conf.AdminConf.ListenURL, config.Conf.AdminConf.CertPath, config.Conf.AdminConf.KeyPath,
105		-	handlers.CombinedLoggingHandler(os.Stdout, adminHandler)))
	102	+	log.Infof("Starting admin server at https://%s\n", config.Conf.AdminConf.ListenURL)
	103	+	log.Info(http.ListenAndServeTLS(config.Conf.AdminConf.ListenURL, config.Conf.AdminConf.CertPath, config.Conf.AdminConf.KeyPath,
	104	+	handlers.CombinedLoggingHandler(log.Writer(), adminHandler)))
106	105		} else {
107		-	Logger.Printf("Starting admin server at http://%s\n", config.Conf.AdminConf.ListenURL)
108		-	Logger.Fatal(http.ListenAndServe(config.Conf.AdminConf.ListenURL, handlers.CombinedLoggingHandler(os.Stdout, adminHandler)))
	106	+	log.Infof("Starting admin server at http://%s\n", config.Conf.AdminConf.ListenURL)
	107	+	log.Info(http.ListenAndServe(config.Conf.AdminConf.ListenURL, handlers.CombinedLoggingHandler(os.Stdout, adminHandler)))
109	108		}
110	109		}()
111	110		wg.Add(1)
		skipped 1 lines
113	112		defer wg.Done()
114	113		phishHandler := gziphandler.GzipHandler(controllers.CreatePhishingRouter())
115	114		if config.Conf.PhishConf.UseTLS { // use TLS for Phish web server if available
116		-	Logger.Printf("Starting phishing server at https://%s\n", config.Conf.PhishConf.ListenURL)
117		-	Logger.Fatal(http.ListenAndServeTLS(config.Conf.PhishConf.ListenURL, config.Conf.PhishConf.CertPath, config.Conf.PhishConf.KeyPath,
118		-	handlers.CombinedLoggingHandler(os.Stdout, phishHandler)))
	115	+	log.Infof("Starting phishing server at https://%s\n", config.Conf.PhishConf.ListenURL)
	116	+	log.Info(http.ListenAndServeTLS(config.Conf.PhishConf.ListenURL, config.Conf.PhishConf.CertPath, config.Conf.PhishConf.KeyPath,
	117	+	handlers.CombinedLoggingHandler(log.Writer(), phishHandler)))
119	118		} else {
120		-	Logger.Printf("Starting phishing server at http://%s\n", config.Conf.PhishConf.ListenURL)
121		-	Logger.Fatal(http.ListenAndServe(config.Conf.PhishConf.ListenURL, handlers.CombinedLoggingHandler(os.Stdout, phishHandler)))
	119	+	log.Infof("Starting phishing server at http://%s\n", config.Conf.PhishConf.ListenURL)
	120	+	log.Fatal(http.ListenAndServe(config.Conf.PhishConf.ListenURL, handlers.CombinedLoggingHandler(os.Stdout, phishHandler)))
122	121		}
123	122		}()
124	123		wg.Wait()
		skipped 2 lines

■ ■ ■ ■ ■ ■

logger/doc.go

1	+	/*
2	+	gophish - Open-Source Phishing Framework
3	+
4	+	The MIT License (MIT)
5	+
6	+	Copyright (c) 2013 Jordan Wright
7	+
8	+	Permission is hereby granted, free of charge, to any person obtaining a copy
9	+	of this software and associated documentation files (the "Software"), to deal
10	+	in the Software without restriction, including without limitation the rights
11	+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12	+	copies of the Software, and to permit persons to whom the Software is
13	+	furnished to do so, subject to the following conditions:
14	+
15	+	The above copyright notice and this permission notice shall be included in
16	+	all copies or substantial portions of the Software.
17	+
18	+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19	+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20	+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21	+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22	+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23	+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24	+	THE SOFTWARE.
25	+	*/
26	+
27	+	// Package logger contains a wrapper around logrus to support a centralized
28	+	// logging config.
29	+	package logger
30	+

■ ■ ■ ■ ■ ■

logger/logger.go

1	+	package logger
2	+
3	+	import (
4	+	"io"
5	+
6	+	"github.com/sirupsen/logrus"
7	+	)
8	+
9	+	// Logger is the main logger that is abstracted in this package.
10	+	// It is exported here for use with gorm.
11	+	var Logger *logrus.Logger
12	+
13	+	func init() {
14	+	Logger = logrus.New()
15	+	Logger.SetLevel(logrus.InfoLevel)
16	+	Logger.Formatter = &logrus.TextFormatter{DisableColors: true}
17	+	}
18	+
19	+	func Debug(args ...interface{}) {
20	+	Logger.Debug(args...)
21	+	}
22	+
23	+	func Debugf(format string, args ...interface{}) {
24	+	Logger.Debugf(format, args...)
25	+	}
26	+
27	+	func Info(args ...interface{}) {
28	+	Logger.Info(args...)
29	+	}
30	+
31	+	func Infof(format string, args ...interface{}) {
32	+	Logger.Infof(format, args...)
33	+	}
34	+
35	+	func Error(args ...interface{}) {
36	+	Logger.Error(args...)
37	+	}
38	+
39	+	func Errorf(format string, args ...interface{}) {
40	+	Logger.Errorf(format, args...)
41	+	}
42	+
43	+	func Warn(args ...interface{}) {
44	+	Logger.Warn(args...)
45	+	}
46	+
47	+	func Warnf(format string, args ...interface{}) {
48	+	Logger.Warnf(format, args...)
49	+	}
50	+
51	+	func Fatal(args ...interface{}) {
52	+	Logger.Fatal(args...)
53	+	}
54	+
55	+	func Fatalf(format string, args ...interface{}) {
56	+	Logger.Fatalf(format, args...)
57	+	}
58	+
59	+	func WithFields(fields logrus.Fields) *logrus.Entry {
60	+	return Logger.WithFields(fields)
61	+	}
62	+
63	+	func Writer() *io.PipeWriter {
64	+	return Logger.Writer()
65	+	}
66	+

■ ■ ■ ■ ■ ■

mailer/mailer.go

		skipped 3 lines
4	4		"context"
5	5		"fmt"
6	6		"io"
7		-	"log"
8	7		"net/textproto"
9		-	"os"
10	8
11	9		"github.com/gophish/gomail"
	10	+	log "github.com/gophish/gophish/logger"
	11	+	"github.com/sirupsen/logrus"
12	12		)
13	13
14	14		// MaxReconnectAttempts is the maximum number of times we should reconnect to a server
		skipped 13 lines
28	28		}
29	29		return errString
30	30		}
31		-
32		-	// Logger is the logger for the worker
33		-	var Logger = log.New(os.Stdout, " ", log.Ldate\|log.Ltime\|log.Lshortfile)
34	31
35	32		// Sender exposes the common operations required for sending email.
36	33		type Sender interface {
		skipped 49 lines
86	83		return
87	84		case ms := <-mw.Queue:
88	85		go func(ctx context.Context, ms []Mail) {
89		-	Logger.Printf("Mailer got %d mail to send", len(ms))
	86	+	log.Infof("Mailer got %d mail to send", len(ms))
90	87		dialer, err := ms[0].GetDialer()
91	88		if err != nil {
92	89		errorMail(err, ms)
		skipped 48 lines
141	138		func sendMail(ctx context.Context, dialer Dialer, ms []Mail) {
142	139		sender, err := dialHost(ctx, dialer)
143	140		if err != nil {
	141	+	log.Warn(err)
144	142		errorMail(err, ms)
145	143		return
146	144		}
		skipped 10 lines
157	155
158	156		err = m.Generate(message)
159	157		if err != nil {
	158	+	log.Warn(err)
160	159		m.Error(err)
161	160		continue
162	161		}
		skipped 6 lines
169	168		// We'll reset the connection so future messages don't incur a
170	169		// different error (see https://github.com/gophish/gophish/issues/787).
171	170		case te.Code >= 400 && te.Code <= 499:
	171	+	log.WithFields(logrus.Fields{
	172	+	"code": te.Code,
	173	+	"email": message.GetHeader("To")[0],
	174	+	}).Warn(err)
172	175		m.Backoff(err)
173	176		sender.Reset()
174	177		continue
		skipped 1 lines
176	179		// since the RFC specifies that running the same commands won't work next time.
177	180		// We should reset our sender and error this message out.
178	181		case te.Code >= 500 && te.Code <= 599:
	182	+	log.WithFields(logrus.Fields{
	183	+	"code": te.Code,
	184	+	"email": message.GetHeader("To")[0],
	185	+	}).Warn(err)
179	186		m.Error(err)
180	187		sender.Reset()
181	188		continue
182	189		// If something else happened, let's just error out and reset the
183	190		// sender
184	191		default:
	192	+	log.WithFields(logrus.Fields{
	193	+	"code": "unknown",
	194	+	"email": message.GetHeader("To")[0],
	195	+	}).Warn(err)
185	196		m.Error(err)
186	197		sender.Reset()
187	198		continue
		skipped 2 lines
190	201		// This likely indicates that something happened to the underlying
191	202		// connection. We'll try to reconnect and, if that fails, we'll
192	203		// error out the remaining emails.
	204	+	log.WithFields(logrus.Fields{
	205	+	"email": message.GetHeader("To")[0],
	206	+	}).Warn(err)
193	207		origErr := err
194	208		sender, err = dialHost(ctx, dialer)
195	209		if err != nil {
		skipped 4 lines
200	214		continue
201	215		}
202	216		}
	217	+	log.WithFields(logrus.Fields{
	218	+	"email": message.GetHeader("To")[0],
	219	+	}).Info("Email sent")
203	220		m.Success()
204	221		}
205	222		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

models/campaign.go

		skipped 3 lines
4	4		"errors"
5	5		"time"
6	6
	7	+	log "github.com/gophish/gophish/logger"
7	8		"github.com/jinzhu/gorm"
	9	+	"github.com/sirupsen/logrus"
8	10		)
9	11
10	12		// Campaign is a struct representing a created campaign
		skipped 19 lines
30	32
31	33		// CampaignResults is a struct representing the results from a campaign
32	34		type CampaignResults struct {
33		-	Id int64 `json:"id"`
34		-	Name string `json:"name"`
35		-	Status string `json:"status"`
36		-	Reported string `json:"reported"`
37		-	Results []Result `json:"results, omitempty"`
38		-	Events []Event `json:"timeline,omitempty"`
	35	+	Id int64 `json:"id"`
	36	+	Name string `json:"name"`
	37	+	Status string `json:"status"`
	38	+	Reported string `json:"reported"`
	39	+	Results []Result `json:"results, omitempty"`
	40	+	Events []Event `json:"timeline,omitempty"`
39	41		}
40	42
41		-	// CampaignsSummary is a struct representing the overview of campaigns
	43	+	// CampaignSummaries is a struct representing the overview of campaigns
42	44		type CampaignSummaries struct {
43	45		Total int64 `json:"total"`
44	46		Campaigns []CampaignSummary `json:"campaigns"`
		skipped 39 lines
84	86		// ErrTemplateNotFound indicates the template specified does not exist in the database
85	87		var ErrTemplateNotFound = errors.New("Template not found")
86	88
87		-	// ErrGroupnNotFound indicates a group specified by the user does not exist in the database
	89	+	// ErrGroupNotFound indicates a group specified by the user does not exist in the database
88	90		var ErrGroupNotFound = errors.New("Group not found")
89	91
90	92		// ErrPageNotFound indicates a page specified by the user does not exist in the database
		skipped 42 lines
133	135		func (c *Campaign) getDetails() error {
134	136		err = db.Model(c).Related(&c.Results).Error
135	137		if err != nil {
136		-	Logger.Printf("%s: results not found for campaign\n", err)
	138	+	log.Warnf("%s: results not found for campaign", err)
137	139		return err
138	140		}
139	141		err = db.Model(c).Related(&c.Events).Error
140	142		if err != nil {
141		-	Logger.Printf("%s: events not found for campaign\n", err)
	143	+	log.Warnf("%s: events not found for campaign", err)
142	144		return err
143	145		}
144	146		err = db.Table("templates").Where("id=?", c.TemplateId).Find(&c.Template).Error
		skipped 2 lines
147	149		return err
148	150		}
149	151		c.Template = Template{Name: "[Deleted]"}
150		-	Logger.Printf("%s: template not found for campaign\n", err)
	152	+	log.Warnf("%s: template not found for campaign", err)
151	153		}
152	154		err = db.Where("template_id=?", c.Template.Id).Find(&c.Template.Attachments).Error
153	155		if err != nil && err != gorm.ErrRecordNotFound {
154		-	Logger.Println(err)
	156	+	log.Warn(err)
155	157		return err
156	158		}
157	159		err = db.Table("pages").Where("id=?", c.PageId).Find(&c.Page).Error
		skipped 2 lines
160	162		return err
161	163		}
162	164		c.Page = Page{Name: "[Deleted]"}
163		-	Logger.Printf("%s: page not found for campaign\n", err)
	165	+	log.Warnf("%s: page not found for campaign", err)
164	166		}
165	167		err = db.Table("smtp").Where("id=?", c.SMTPId).Find(&c.SMTP).Error
166	168		if err != nil {
		skipped 2 lines
169	171		return err
170	172		}
171	173		c.SMTP = SMTP{Name: "[Deleted]"}
172		-	Logger.Printf("%s: sending profile not found for campaign\n", err)
	174	+	log.Warnf("%s: sending profile not found for campaign", err)
173	175		}
174	176		err = db.Where("smtp_id=?", c.SMTP.Id).Find(&c.SMTP.Headers).Error
175	177		if err != nil && err != gorm.ErrRecordNotFound {
176		-	Logger.Println(err)
	178	+	log.Warn(err)
177	179		return err
178	180		}
179	181		return nil
		skipped 54 lines
234	236		cs := []Campaign{}
235	237		err := db.Model(&User{Id: uid}).Related(&cs).Error
236	238		if err != nil {
237		-	Logger.Println(err)
	239	+	log.Error(err)
238	240		}
239		-	for i, _ := range cs {
	241	+	for i := range cs {
240	242		err = cs[i].getDetails()
241	243		if err != nil {
242		-	Logger.Println(err)
	244	+	log.Error(err)
243	245		}
244	246		}
245	247		return cs, err
		skipped 9 lines
255	257		query = query.Select("id, name, created_date, launch_date, completed_date, status")
256	258		err := query.Scan(&cs).Error
257	259		if err != nil {
258		-	Logger.Println(err)
	260	+	log.Error(err)
259	261		return overview, err
260	262		}
261	263		for i := range cs {
262	264		s, err := getCampaignStats(cs[i].Id)
263	265		if err != nil {
264		-	Logger.Println(err)
	266	+	log.Error(err)
265	267		return overview, err
266	268		}
267	269		cs[i].Stats = s
		skipped 10 lines
278	280		query = query.Select("id, name, created_date, launch_date, completed_date, status")
279	281		err := query.Scan(&cs).Error
280	282		if err != nil {
281		-	Logger.Println(err)
	283	+	log.Error(err)
282	284		return cs, err
283	285		}
284	286		s, err := getCampaignStats(cs.Id)
285	287		if err != nil {
286		-	Logger.Println(err)
	288	+	log.Error(err)
287	289		return cs, err
288	290		}
289	291		cs.Stats = s
		skipped 5 lines
295	297		c := Campaign{}
296	298		err := db.Where("id = ?", id).Where("user_id = ?", uid).Find(&c).Error
297	299		if err != nil {
298		-	Logger.Printf("%s: campaign not found\n", err)
	300	+	log.Errorf("%s: campaign not found", err)
299	301		return c, err
300	302		}
301	303		err = c.getDetails()
302	304		return c, err
303	305		}
304	306
	307	+	// GetCampaignResults returns just the campaign results for the given campaign
305	308		func GetCampaignResults(id int64, uid int64) (CampaignResults, error) {
306	309		cr := CampaignResults{}
307	310		err := db.Table("campaigns").Where("id=? and user_id=?", id, uid).Find(&cr).Error
308	311		if err != nil {
309		-	Logger.Printf("%s: campaign not found\n", err)
	312	+	log.WithFields(logrus.Fields{
	313	+	"campaign_id": id,
	314	+	"error": err,
	315	+	}).Error(err)
310	316		return cr, err
311	317		}
312	318		err = db.Table("results").Where("campaign_id=? and user_id=?", cr.Id, uid).Find(&cr.Results).Error
313	319		if err != nil {
314		-	Logger.Printf("%s: results not found for campaign\n", err)
	320	+	log.Errorf("%s: results not found for campaign", err)
315	321		return cr, err
316	322		}
317	323		err = db.Table("events").Where("campaign_id=?", cr.Id).Find(&cr.Events).Error
318	324		if err != nil {
319		-	Logger.Printf("%s: events not found for campaign\n", err)
	325	+	log.Errorf("%s: events not found for campaign", err)
320	326		return cr, err
321	327		}
322	328		return cr, err
		skipped 5 lines
328	334		err := db.Where("launch_date <= ?", t).
329	335		Where("status = ?", CAMPAIGN_QUEUED).Find(&cs).Error
330	336		if err != nil {
331		-	Logger.Println(err)
	337	+	log.Error(err)
332	338		}
333		-	Logger.Printf("Found %d Campaigns to run\n", len(cs))
334		-	for i, _ := range cs {
	339	+	log.Infof("Found %d Campaigns to run\n", len(cs))
	340	+	for i := range cs {
335	341		err = cs[i].getDetails()
336	342		if err != nil {
337		-	Logger.Println(err)
	343	+	log.Error(err)
338	344		}
339	345		}
340	346		return cs, err
		skipped 21 lines
362	368		for i, g := range c.Groups {
363	369		c.Groups[i], err = GetGroupByName(g.Name, uid)
364	370		if err == gorm.ErrRecordNotFound {
365		-	Logger.Printf("Error - Group %s does not exist", g.Name)
	371	+	log.WithFields(logrus.Fields{
	372	+	"group": g.Name,
	373	+	}).Error("Group does not exist")
366	374		return ErrGroupNotFound
367	375		} else if err != nil {
368		-	Logger.Println(err)
	376	+	log.Error(err)
369	377		return err
370	378		}
371	379		}
372	380		// Check to make sure the template exists
373	381		t, err := GetTemplateByName(c.Template.Name, uid)
374	382		if err == gorm.ErrRecordNotFound {
375		-	Logger.Printf("Error - Template %s does not exist", t.Name)
	383	+	log.WithFields(logrus.Fields{
	384	+	"template": t.Name,
	385	+	}).Error("Template does not exist")
376	386		return ErrTemplateNotFound
377	387		} else if err != nil {
378		-	Logger.Println(err)
	388	+	log.Error(err)
379	389		return err
380	390		}
381	391		c.Template = t
		skipped 1 lines
383	393		// Check to make sure the page exists
384	394		p, err := GetPageByName(c.Page.Name, uid)
385	395		if err == gorm.ErrRecordNotFound {
386		-	Logger.Printf("Error - Page %s does not exist", p.Name)
	396	+	log.WithFields(logrus.Fields{
	397	+	"page": p.Name,
	398	+	}).Error("Page does not exist")
387	399		return ErrPageNotFound
388	400		} else if err != nil {
389		-	Logger.Println(err)
	401	+	log.Error(err)
390	402		return err
391	403		}
392	404		c.Page = p
		skipped 1 lines
394	406		// Check to make sure the sending profile exists
395	407		s, err := GetSMTPByName(c.SMTP.Name, uid)
396	408		if err == gorm.ErrRecordNotFound {
397		-	Logger.Printf("Error - Sending profile %s does not exist", s.Name)
398		-	return ErrPageNotFound
	409	+	log.WithFields(logrus.Fields{
	410	+	"smtp": s.Name,
	411	+	}).Error("Sending profile does not exist")
	412	+	return ErrSMTPNotFound
399	413		} else if err != nil {
400		-	Logger.Println(err)
	414	+	log.Error(err)
401	415		return err
402	416		}
403	417		c.SMTP = s
		skipped 1 lines
405	419		// Insert into the DB
406	420		err = db.Save(c).Error
407	421		if err != nil {
408		-	Logger.Println(err)
	422	+	log.Error(err)
409	423		return err
410	424		}
411	425		err = c.AddEvent(Event{Message: "Campaign Created"})
412	426		if err != nil {
413		-	Logger.Println(err)
	427	+	log.Error(err)
414	428		}
415	429		// Insert all the results
416	430		resultMap := make(map[string]bool)
		skipped 22 lines
439	453		}
440	454		err = r.GenerateId()
441	455		if err != nil {
442		-	Logger.Println(err)
	456	+	log.Error(err)
443	457		continue
444	458		}
445	459		err = db.Save(r).Error
446	460		if err != nil {
447		-	Logger.Printf("Error adding result record for target %s\n", t.Email)
448		-	Logger.Println(err)
	461	+	log.WithFields(logrus.Fields{
	462	+	"email": t.Email,
	463	+	}).Error(err)
449	464		}
450	465		c.Results = append(c.Results, *r)
451	466		err = GenerateMailLog(c, r)
452	467		if err != nil {
453		-	Logger.Println(err)
	468	+	log.Error(err)
454	469		continue
455	470		}
456	471		}
		skipped 4 lines
461	476
462	477		//DeleteCampaign deletes the specified campaign
463	478		func DeleteCampaign(id int64) error {
464		-	Logger.Printf("Deleting campaign %d\n", id)
	479	+	log.WithFields(logrus.Fields{
	480	+	"campaign_id": id,
	481	+	}).Info("Deleting campaign")
465	482		// Delete all the campaign results
466	483		err := db.Where("campaign_id=?", id).Delete(&Result{}).Error
467	484		if err != nil {
468		-	Logger.Println(err)
	485	+	log.Error(err)
469	486		return err
470	487		}
471	488		err = db.Where("campaign_id=?", id).Delete(&Event{}).Error
472	489		if err != nil {
473		-	Logger.Println(err)
	490	+	log.Error(err)
474	491		return err
475	492		}
476	493		// Delete the campaign
477	494		err = db.Delete(&Campaign{Id: id}).Error
478	495		if err != nil {
479		-	Logger.Println(err)
	496	+	log.Error(err)
480	497		}
481	498		return err
482	499		}
		skipped 1 lines
484	501		// CompleteCampaign effectively "ends" a campaign.
485	502		// Any future emails clicked will return a simple "404" page.
486	503		func CompleteCampaign(id int64, uid int64) error {
487		-	Logger.Printf("Marking campaign %d as complete\n", id)
	504	+	log.WithFields(logrus.Fields{
	505	+	"campaign_id": id,
	506	+	}).Info("Marking campaign as complete")
488	507		c, err := GetCampaign(id, uid)
489	508		if err != nil {
490	509		return err
		skipped 7 lines
498	517		c.Status = CAMPAIGN_COMPLETE
499	518		err = db.Where("id=? and user_id=?", id, uid).Save(&c).Error
500	519		if err != nil {
501		-	Logger.Println(err)
	520	+	log.Error(err)
502	521		}
503	522		return err
504	523		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

models/email_request.go

		skipped 7 lines
8	8		"strings"
9	9
10	10		"github.com/gophish/gomail"
	11	+	log "github.com/gophish/gophish/logger"
11	12		"github.com/gophish/gophish/mailer"
12	13		)
13	14
		skipped 65 lines
79	80		for _, header := range s.SMTP.Headers {
80	81		key, err := buildTemplate(header.Key, s)
81	82		if err != nil {
82		-	Logger.Println(err)
	83	+	log.Error(err)
83	84		}
84	85
85	86		value, err := buildTemplate(header.Value, s)
86	87		if err != nil {
87		-	Logger.Println(err)
	88	+	log.Error(err)
88	89		}
89	90
90	91		// Add our header immediately
		skipped 3 lines
94	95		// Parse remaining templates
95	96		subject, err := buildTemplate(s.Template.Subject, s)
96	97		if err != nil {
97		-	Logger.Println(err)
	98	+	log.Error(err)
98	99		}
99	100		// don't set the Subject header if it is blank
100	101		if len(subject) != 0 {
		skipped 4 lines
105	106		if s.Template.Text != "" {
106	107		text, err := buildTemplate(s.Template.Text, s)
107	108		if err != nil {
108		-	Logger.Println(err)
	109	+	log.Error(err)
109	110		}
110	111		msg.SetBody("text/plain", text)
111	112		}
112	113		if s.Template.HTML != "" {
113	114		html, err := buildTemplate(s.Template.HTML, s)
114	115		if err != nil {
115		-	Logger.Println(err)
	116	+	log.Error(err)
116	117		}
117	118		if s.Template.Text == "" {
118	119		msg.SetBody("text/html", html)
		skipped 24 lines

■ ■ ■ ■ ■ ■

models/group.go

		skipped 5 lines
6	6		"net/mail"
7	7		"time"
8	8
	9	+	log "github.com/gophish/gophish/logger"
9	10		"github.com/jinzhu/gorm"
	11	+	"github.com/sirupsen/logrus"
10	12		)
11	13
12	14		// Group contains the fields needed for a user -> group mapping
		skipped 76 lines
89	91		gs := []Group{}
90	92		err := db.Where("user_id=?", uid).Find(&gs).Error
91	93		if err != nil {
92		-	Logger.Println(err)
	94	+	log.Error(err)
93	95		return gs, err
94	96		}
95		-	for i, _ := range gs {
	97	+	for i := range gs {
96	98		gs[i].Targets, err = GetTargets(gs[i].Id)
97	99		if err != nil {
98		-	Logger.Println(err)
	100	+	log.Error(err)
99	101		}
100	102		}
101	103		return gs, nil
		skipped 6 lines
108	110		query := db.Table("groups").Where("user_id=?", uid)
109	111		err := query.Select("id, name, modified_date").Scan(&gs.Groups).Error
110	112		if err != nil {
111		-	Logger.Println(err)
	113	+	log.Error(err)
112	114		return gs, err
113	115		}
114	116		for i := range gs.Groups {
		skipped 12 lines
127	129		g := Group{}
128	130		err := db.Where("user_id=? and id=?", uid, id).Find(&g).Error
129	131		if err != nil {
130		-	Logger.Println(err)
	132	+	log.Error(err)
131	133		return g, err
132	134		}
133	135		g.Targets, err = GetTargets(g.Id)
134	136		if err != nil {
135		-	Logger.Println(err)
	137	+	log.Error(err)
136	138		}
137	139		return g, nil
138	140		}
		skipped 4 lines
143	145		query := db.Table("groups").Where("user_id=? and id=?", uid, id)
144	146		err := query.Select("id, name, modified_date").Scan(&g).Error
145	147		if err != nil {
146		-	Logger.Println(err)
	148	+	log.Error(err)
147	149		return g, err
148	150		}
149	151		query = db.Table("group_targets").Where("group_id=?", id)
		skipped 9 lines
159	161		g := Group{}
160	162		err := db.Where("user_id=? and name=?", uid, n).Find(&g).Error
161	163		if err != nil {
162		-	Logger.Println(err)
	164	+	log.Error(err)
163	165		return g, err
164	166		}
165	167		g.Targets, err = GetTargets(g.Id)
166	168		if err != nil {
167		-	Logger.Println(err)
	169	+	log.Error(err)
168	170		}
169	171		return g, err
170	172		}
		skipped 6 lines
177	179		// Insert the group into the DB
178	180		err = db.Save(g).Error
179	181		if err != nil {
180		-	Logger.Println(err)
	182	+	log.Error(err)
181	183		return err
182	184		}
183	185		for _, t := range g.Targets {
		skipped 11 lines
195	197		ts := []Target{}
196	198		ts, err = GetTargets(g.Id)
197	199		if err != nil {
198		-	Logger.Printf("Error getting targets from group ID: %d", g.Id)
	200	+	log.WithFields(logrus.Fields{
	201	+	"group_id": g.Id,
	202	+	}).Error("Error getting targets from group")
199	203		return err
200	204		}
201	205		// Check existing targets, removing any that are no longer in the group.
		skipped 11 lines
213	217		if !tExists {
214	218		err = db.Where("group_id=? and target_id=?", g.Id, t.Id).Delete(&GroupTarget{}).Error
215	219		if err != nil {
216		-	Logger.Printf("Error deleting email %s\n", t.Email)
	220	+	log.WithFields(logrus.Fields{
	221	+	"email": t.Email,
	222	+	}).Error("Error deleting email")
217	223		}
218	224		}
219	225		}
		skipped 17 lines
237	243		}
238	244		err = db.Save(g).Error
239	245		if err != nil {
240		-	Logger.Println(err)
	246	+	log.Error(err)
241	247		return err
242	248		}
243	249		return nil
		skipped 4 lines
248	254		// Delete all the group_targets entries for this group
249	255		err := db.Where("group_id=?", g.Id).Delete(&GroupTarget{}).Error
250	256		if err != nil {
251		-	Logger.Println(err)
	257	+	log.Error(err)
252	258		return err
253	259		}
254	260		// Delete the group itself
255	261		err = db.Delete(g).Error
256	262		if err != nil {
257		-	Logger.Println(err)
	263	+	log.Error(err)
258	264		return err
259	265		}
260	266		return err
		skipped 1 lines
262	268
263	269		func insertTargetIntoGroup(t Target, gid int64) error {
264	270		if _, err = mail.ParseAddress(t.Email); err != nil {
265		-	Logger.Printf("Invalid email %s\n", t.Email)
	271	+	log.WithFields(logrus.Fields{
	272	+	"email": t.Email,
	273	+	}).Error("Invalid email")
266	274		return err
267	275		}
268	276		trans := db.Begin()
269	277		trans.Where(t).FirstOrCreate(&t)
270	278		if err != nil {
271		-	Logger.Printf("Error adding target: %s\n", t.Email)
	279	+	log.WithFields(logrus.Fields{
	280	+	"email": t.Email,
	281	+	}).Error("Error adding target")
272	282		return err
273	283		}
274	284		err = trans.Where("group_id=? and target_id=?", gid, t.Id).Find(&GroupTarget{}).Error
275	285		if err == gorm.ErrRecordNotFound {
276	286		err = trans.Save(&GroupTarget{GroupId: gid, TargetId: t.Id}).Error
277	287		if err != nil {
278		-	Logger.Println(err)
	288	+	log.Error(err)
279	289		return err
280	290		}
281	291		}
282	292		if err != nil {
283		-	Logger.Printf("Error adding many-many mapping for %s\n", t.Email)
	293	+	log.WithFields(logrus.Fields{
	294	+	"email": t.Email,
	295	+	}).Error("Error adding many-many mapping")
284	296		return err
285	297		}
286	298		err = trans.Commit().Error
287	299		if err != nil {
288		-	Logger.Printf("Error committing db changes\n")
	300	+	log.Error("Error committing db changes")
289	301		return err
290	302		}
291	303		return nil
		skipped 8 lines
300	312		}
301	313		err := db.Model(&target).Where("id = ?", target.Id).Updates(targetInfo).Error
302	314		if err != nil {
303		-	Logger.Printf("Error updating target information for %s\n", target.Email)
	315	+	log.WithFields(logrus.Fields{
	316	+	"email": target.Email,
	317	+	}).Error("Error updating target information")
304	318		}
305	319		return err
306	320		}
		skipped 8 lines

■ ■ ■ ■ ■ ■

models/maillog.go

		skipped 15 lines
16	16		"time"
17	17
18	18		"github.com/gophish/gomail"
	19	+	log "github.com/gophish/gophish/logger"
19	20		"github.com/gophish/gophish/mailer"
20	21		)
21	22
		skipped 98 lines
120	121		}
121	122		ej, err := json.Marshal(es)
122	123		if err != nil {
123		-	Logger.Println(err)
	124	+	log.Warn(err)
124	125		}
125	126		err = c.AddEvent(Event{Email: r.Email, Message: EVENT_SENDING_ERROR, Details: string(ej)})
126	127		return err
		skipped 3 lines
130	131		// maillog refers to. Since MailLog errors are permanent,
131	132		// this action also deletes the maillog.
132	133		func (m *MailLog) Error(e error) error {
133		-	Logger.Printf("Erroring out result %s\n", m.RId)
134	134		r, err := GetResult(m.RId)
135	135		if err != nil {
	136	+	log.Warn(err)
136	137		return err
137	138		}
138	139		// Update the result
139	140		err = r.UpdateStatus(ERROR)
140	141		if err != nil {
	142	+	log.Warn(err)
141	143		return err
142	144		}
143	145		// Update the campaign events
144	146		err = m.addError(e)
145	147		if err != nil {
	148	+	log.Warn(err)
146	149		return err
147	150		}
148	151		err = db.Delete(m).Error
		skipped 98 lines
247	250		for _, header := range c.SMTP.Headers {
248	251		key, err := buildTemplate(header.Key, td)
249	252		if err != nil {
250		-	Logger.Println(err)
	253	+	log.Warn(err)
251	254		}
252	255
253	256		value, err := buildTemplate(header.Value, td)
254	257		if err != nil {
255		-	Logger.Println(err)
	258	+	log.Warn(err)
256	259		}
257	260
258	261		// Add our header immediately
		skipped 3 lines
262	265		// Parse remaining templates
263	266		subject, err := buildTemplate(c.Template.Subject, td)
264	267		if err != nil {
265		-	Logger.Println(err)
	268	+	log.Warn(err)
266	269		}
267	270		// don't set Subject header if the subject is empty
268	271		if len(subject) != 0 {
		skipped 4 lines
273	276		if c.Template.Text != "" {
274	277		text, err := buildTemplate(c.Template.Text, td)
275	278		if err != nil {
276		-	Logger.Println(err)
	279	+	log.Warn(err)
277	280		}
278	281		msg.SetBody("text/plain", text)
279	282		}
280	283		if c.Template.HTML != "" {
281	284		html, err := buildTemplate(c.Template.HTML, td)
282	285		if err != nil {
283		-	Logger.Println(err)
	286	+	log.Warn(err)
284	287		}
285	288		if c.Template.Text == "" {
286	289		msg.SetBody("text/html", html)
		skipped 22 lines
309	312		err := db.Where("send_date <= ? AND processing = ?", t, false).
310	313		Find(&ms).Error
311	314		if err != nil {
312		-	Logger.Println(err)
	315	+	log.Warn(err)
313	316		}
314	317		return ms, err
315	318		}
		skipped 31 lines

■ ■ ■ ■ ■ ■

models/models.go

		skipped 3 lines
4	4		"crypto/rand"
5	5		"fmt"
6	6		"io"
7		-	"log"
8		-	"os"
9	7
10	8		"bitbucket.org/liamstask/goose/lib/goose"
11	9
12		-	_ "github.com/go-sql-driver/mysql"
	10	+	_ "github.com/go-sql-driver/mysql" // Blank import needed to import mysql
13	11		"github.com/gophish/gophish/config"
	12	+	log "github.com/gophish/gophish/logger"
14	13		"github.com/jinzhu/gorm"
15	14		_ "github.com/mattn/go-sqlite3" // Blank import needed to import sqlite3
16	15		)
17	16
18	17		var db *gorm.DB
19	18		var err error
20		-
21		-	// Logger is a global logger used to show informational, warning, and error messages
22		-	var Logger = log.New(os.Stdout, " ", log.Ldate\|log.Ltime\|log.Lshortfile)
23	19
24	20		const (
25	21		CAMPAIGN_IN_PROGRESS string = "In progress"
		skipped 66 lines
92	88		// Get the latest possible migration
93	89		latest, err := goose.GetMostRecentDBVersion(migrateConf.MigrationsDir)
94	90		if err != nil {
95		-	Logger.Println(err)
	91	+	log.Error(err)
96	92		return err
97	93		}
98	94		// Open our database connection
99	95		db, err = gorm.Open(config.Conf.DBName, config.Conf.DBPath)
100	96		db.LogMode(false)
101		-	db.SetLogger(Logger)
	97	+	db.SetLogger(log.Logger)
102	98		db.DB().SetMaxOpenConns(1)
103	99		if err != nil {
104		-	Logger.Println(err)
	100	+	log.Error(err)
105	101		return err
106	102		}
107	103		// Migrate up to the latest version
108	104		err = goose.RunMigrationsOnDb(migrateConf, migrateConf.MigrationsDir, latest, db.DB())
109	105		if err != nil {
110		-	Logger.Println(err)
	106	+	log.Error(err)
111	107		return err
112	108		}
113	109		// Create the admin user if it doesn't exist
		skipped 7 lines
121	117		initUser.ApiKey = generateSecureKey()
122	118		err = db.Save(&initUser).Error
123	119		if err != nil {
124		-	Logger.Println(err)
	120	+	log.Error(err)
125	121		return err
126	122		}
127	123		}
		skipped 3 lines

■ ■ ■ ■ ■ ■

models/page.go

		skipped 5 lines
6	6		"time"
7	7
8	8		"github.com/PuerkitoBio/goquery"
	9	+	log "github.com/gophish/gophish/logger"
9	10		)
10	11
11	12		// Page contains the fields used for a Page model
		skipped 65 lines
77	78		ps := []Page{}
78	79		err := db.Where("user_id=?", uid).Find(&ps).Error
79	80		if err != nil {
80		-	Logger.Println(err)
	81	+	log.Error(err)
81	82		return ps, err
82	83		}
83	84		return ps, err
		skipped 4 lines
88	89		p := Page{}
89	90		err := db.Where("user_id=? and id=?", uid, id).Find(&p).Error
90	91		if err != nil {
91		-	Logger.Println(err)
	92	+	log.Error(err)
92	93		}
93	94		return p, err
94	95		}
		skipped 3 lines
98	99		p := Page{}
99	100		err := db.Where("user_id=? and name=?", uid, n).Find(&p).Error
100	101		if err != nil {
101		-	Logger.Println(err)
	102	+	log.Error(err)
102	103		}
103	104		return p, err
104	105		}
		skipped 2 lines
107	108		func PostPage(p *Page) error {
108	109		err := p.Validate()
109	110		if err != nil {
110		-	Logger.Println(err)
	111	+	log.Error(err)
111	112		return err
112	113		}
113	114		// Insert into the DB
114	115		err = db.Save(p).Error
115	116		if err != nil {
116		-	Logger.Println(err)
	117	+	log.Error(err)
117	118		}
118	119		return err
119	120		}
		skipped 4 lines
124	125		err := p.Validate()
125	126		err = db.Where("id=?", p.Id).Save(p).Error
126	127		if err != nil {
127		-	Logger.Println(err)
	128	+	log.Error(err)
128	129		}
129	130		return err
130	131		}
		skipped 3 lines
134	135		func DeletePage(id int64, uid int64) error {
135	136		err = db.Where("user_id=?", uid).Delete(Page{Id: id}).Error
136	137		if err != nil {
137		-	Logger.Println(err)
	138	+	log.Error(err)
138	139		}
139	140		return err
140	141		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

models/result.go

		skipped 2 lines
3	3		import (
4	4		"crypto/rand"
5	5		"fmt"
6		-	"log"
7	6		"math/big"
8	7		"net"
9	8		"net/mail"
10	9		"time"
11	10
	11	+	log "github.com/gophish/gophish/logger"
12	12		"github.com/jinzhu/gorm"
13	13		"github.com/oschwald/maxminddb-golang"
14	14		)
		skipped 83 lines
98	98		return nil
99	99		}
100	100
101		-	// Returns the email address to use in the "To" header of the email
	101	+	// FormatAddress returns the email address to use in the "To" header of the email
102	102		func (r *Result) FormatAddress() string {
103	103		addr := r.Email
104	104		if r.FirstName != "" && r.LastName != "" {
		skipped 17 lines

■ ■ ■ ■ ■ ■

models/smtp.go

		skipped 9 lines
10	10		"time"
11	11
12	12		"github.com/gophish/gomail"
	13	+	log "github.com/gophish/gophish/logger"
13	14		"github.com/gophish/gophish/mailer"
14	15		"github.com/jinzhu/gorm"
15	16		)
		skipped 88 lines
104	105		// double check here.
105	106		port, err := strconv.Atoi(hp[1])
106	107		if err != nil {
107		-	Logger.Println(err)
	108	+	log.Error(err)
108	109		return nil, err
109	110		}
110	111		d := gomail.NewDialer(hp[0], port, s.Username, s.Password)
		skipped 3 lines
114	115		}
115	116		hostname, err := os.Hostname()
116	117		if err != nil {
117		-	Logger.Println(err)
	118	+	log.Error(err)
118	119		hostname = "localhost"
119	120		}
120	121		d.LocalName = hostname
		skipped 5 lines
126	127		ss := []SMTP{}
127	128		err := db.Where("user_id=?", uid).Find(&ss).Error
128	129		if err != nil {
129		-	Logger.Println(err)
	130	+	log.Error(err)
130	131		return ss, err
131	132		}
132	133		for i := range ss {
133	134		err = db.Where("smtp_id=?", ss[i].Id).Find(&ss[i].Headers).Error
134	135		if err != nil && err != gorm.ErrRecordNotFound {
135		-	Logger.Println(err)
	136	+	log.Error(err)
136	137		return ss, err
137	138		}
138	139		}
		skipped 5 lines
144	145		s := SMTP{}
145	146		err := db.Where("user_id=? and id=?", uid, id).Find(&s).Error
146	147		if err != nil {
147		-	Logger.Println(err)
	148	+	log.Error(err)
148	149		}
149	150		err = db.Where("smtp_id=?", s.Id).Find(&s.Headers).Error
150	151		if err != nil && err != gorm.ErrRecordNotFound {
151		-	Logger.Println(err)
	152	+	log.Error(err)
152	153		return s, err
153	154		}
154	155		return s, err
		skipped 4 lines
159	160		s := SMTP{}
160	161		err := db.Where("user_id=? and name=?", uid, n).Find(&s).Error
161	162		if err != nil {
162		-	Logger.Println(err)
	163	+	log.Error(err)
163	164		return s, err
164	165		}
165	166		err = db.Where("smtp_id=?", s.Id).Find(&s.Headers).Error
166	167		if err != nil && err != gorm.ErrRecordNotFound {
167		-	Logger.Println(err)
	168	+	log.Error(err)
168	169		}
169	170		return s, err
170	171		}
		skipped 2 lines
173	174		func PostSMTP(s *SMTP) error {
174	175		err := s.Validate()
175	176		if err != nil {
176		-	Logger.Println(err)
	177	+	log.Error(err)
177	178		return err
178	179		}
179	180		// Insert into the DB
180	181		err = db.Save(s).Error
181	182		if err != nil {
182		-	Logger.Println(err)
	183	+	log.Error(err)
183	184		}
184	185		// Save custom headers
185	186		for i := range s.Headers {
186	187		s.Headers[i].SMTPId = s.Id
187	188		err := db.Save(&s.Headers[i]).Error
188	189		if err != nil {
189		-	Logger.Println(err)
	190	+	log.Error(err)
190	191		return err
191	192		}
192	193		}
		skipped 5 lines
198	199		func PutSMTP(s *SMTP) error {
199	200		err := s.Validate()
200	201		if err != nil {
201		-	Logger.Println(err)
	202	+	log.Error(err)
202	203		return err
203	204		}
204	205		err = db.Where("id=?", s.Id).Save(s).Error
205	206		if err != nil {
206		-	Logger.Println(err)
	207	+	log.Error(err)
207	208		}
208	209		// Delete all custom headers, and replace with new ones
209	210		err = db.Where("smtp_id=?", s.Id).Delete(&Header{}).Error
210	211		if err != nil && err != gorm.ErrRecordNotFound {
211		-	Logger.Println(err)
	212	+	log.Error(err)
212	213		return err
213	214		}
214	215		for i := range s.Headers {
215	216		s.Headers[i].SMTPId = s.Id
216	217		err := db.Save(&s.Headers[i]).Error
217	218		if err != nil {
218		-	Logger.Println(err)
	219	+	log.Error(err)
219	220		return err
220	221		}
221	222		}
		skipped 6 lines
228	229		// Delete all custom headers
229	230		err = db.Where("smtp_id=?", id).Delete(&Header{}).Error
230	231		if err != nil {
231		-	Logger.Println(err)
	232	+	log.Error(err)
232	233		return err
233	234		}
234	235		err = db.Where("user_id=?", uid).Delete(SMTP{Id: id}).Error
235	236		if err != nil {
236		-	Logger.Println(err)
	237	+	log.Error(err)
237	238		}
238	239		return err
239	240		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

models/template.go

		skipped 5 lines
6	6		"html/template"
7	7		"time"
8	8
	9	+	log "github.com/gophish/gophish/logger"
9	10		"github.com/jinzhu/gorm"
10	11		)
11	12
		skipped 66 lines
78	79		ts := []Template{}
79	80		err := db.Where("user_id=?", uid).Find(&ts).Error
80	81		if err != nil {
81		-	Logger.Println(err)
	82	+	log.Error(err)
82	83		return ts, err
83	84		}
84	85		for i, _ := range ts {
		skipped 3 lines
88	89		ts[i].Attachments = make([]Attachment, 0)
89	90		}
90	91		if err != nil && err != gorm.ErrRecordNotFound {
91		-	Logger.Println(err)
	92	+	log.Error(err)
92	93		return ts, err
93	94		}
94	95		}
		skipped 5 lines
100	101		t := Template{}
101	102		err := db.Where("user_id=? and id=?", uid, id).Find(&t).Error
102	103		if err != nil {
103		-	Logger.Println(err)
	104	+	log.Error(err)
104	105		return t, err
105	106		}
106	107
107	108		// Get Attachments
108	109		err = db.Where("template_id=?", t.Id).Find(&t.Attachments).Error
109	110		if err != nil && err != gorm.ErrRecordNotFound {
110		-	Logger.Println(err)
	111	+	log.Error(err)
111	112		return t, err
112	113		}
113	114		if err == nil && len(t.Attachments) == 0 {
		skipped 7 lines
121	122		t := Template{}
122	123		err := db.Where("user_id=? and name=?", uid, n).Find(&t).Error
123	124		if err != nil {
124		-	Logger.Println(err)
	125	+	log.Error(err)
125	126		return t, err
126	127		}
127	128
128	129		// Get Attachments
129	130		err = db.Where("template_id=?", t.Id).Find(&t.Attachments).Error
130	131		if err != nil && err != gorm.ErrRecordNotFound {
131		-	Logger.Println(err)
	132	+	log.Error(err)
132	133		return t, err
133	134		}
134	135		if err == nil && len(t.Attachments) == 0 {
		skipped 10 lines
145	146		}
146	147		err = db.Save(t).Error
147	148		if err != nil {
148		-	Logger.Println(err)
	149	+	log.Error(err)
149	150		return err
150	151		}
151	152
152	153		// Save every attachment
153		-	for i, _ := range t.Attachments {
154		-	Logger.Println(t.Attachments[i].Name)
	154	+	for i := range t.Attachments {
155	155		t.Attachments[i].TemplateId = t.Id
156	156		err := db.Save(&t.Attachments[i]).Error
157	157		if err != nil {
158		-	Logger.Println(err)
	158	+	log.Error(err)
159	159		return err
160	160		}
161	161		}
		skipped 9 lines
171	171		// Delete all attachments, and replace with new ones
172	172		err = db.Where("template_id=?", t.Id).Delete(&Attachment{}).Error
173	173		if err != nil && err != gorm.ErrRecordNotFound {
174		-	Logger.Println(err)
	174	+	log.Error(err)
175	175		return err
176	176		}
177	177		if err == gorm.ErrRecordNotFound {
		skipped 3 lines
181	181		t.Attachments[i].TemplateId = t.Id
182	182		err := db.Save(&t.Attachments[i]).Error
183	183		if err != nil {
184		-	Logger.Println(err)
	184	+	log.Error(err)
185	185		return err
186	186		}
187	187		}
		skipped 1 lines
189	189		// Save final template
190	190		err = db.Where("id=?", t.Id).Save(t).Error
191	191		if err != nil {
192		-	Logger.Println(err)
	192	+	log.Error(err)
193	193		return err
194	194		}
195	195		return nil
		skipped 5 lines
201	201		// Delete attachments
202	202		err := db.Where("template_id=?", id).Delete(&Attachment{}).Error
203	203		if err != nil {
204		-	Logger.Println(err)
	204	+	log.Error(err)
205	205		return err
206	206		}
207	207
208	208		// Finally, delete the template itself
209	209		err = db.Where("user_id=?", uid).Delete(Template{Id: id}).Error
210	210		if err != nil {
211		-	Logger.Println(err)
	211	+	log.Error(err)
212	212		return err
213	213		}
214	214		return nil
		skipped 2 lines

■ ■ ■ ■ ■ ■

util/util.go

		skipped 10 lines
11	11		"fmt"
12	12		"io"
13	13		"io/ioutil"
14		-	"log"
15	14		"math/big"
16	15		"net/http"
17	16		"net/mail"
18	17		"os"
19	18		"time"
20	19
	20	+	log "github.com/gophish/gophish/logger"
21	21		"github.com/gophish/gophish/models"
22	22		"github.com/jordan-wright/email"
23	23		)
24		-
25		-	// Logger is used to send logging messages to stdout.
26		-	var Logger = log.New(os.Stdout, " ", log.Ldate\|log.Ltime\|log.Lshortfile)
27	24
28	25		// ParseMail takes in an HTTP Request and returns an Email object
29	26		// TODO: This function will likely be changed to take in a []byte
		skipped 94 lines
124	121		return nil
125	122		}
126	123
127		-	Logger.Printf("Creating new self-signed certificates for administration interface...\n")
	124	+	log.Infof("Creating new self-signed certificates for administration interface")
128	125
129	126		priv, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
130	127
		skipped 46 lines
177	174		pem.Encode(keyOut, &pem.Block{Type: "EC PRIVATE KEY", Bytes: b})
178	175		keyOut.Close()
179	176
180		-	Logger.Println("TLS Certificate Generation complete")
	177	+	log.Info("TLS Certificate Generation complete")
181	178		return nil
182	179		}
183	180

■ ■ ■ ■ ■ ■

worker/worker.go

1	1		package worker
2	2
3	3		import (
4		-	"log"
5		-	"os"
6	4		"time"
7	5
	6	+	log "github.com/gophish/gophish/logger"
8	7		"github.com/gophish/gophish/mailer"
9	8		"github.com/gophish/gophish/models"
	9	+	"github.com/sirupsen/logrus"
10	10		)
11	11
12		-	// Logger is the logger for the worker
13		-	var Logger = log.New(os.Stdout, " ", log.Ldate\|log.Ltime\|log.Lshortfile)
14		-
15	12		// Worker is the background worker that handles watching for new campaigns and sending emails appropriately.
16	13		type Worker struct{}
17	14
		skipped 5 lines
23	20		// Start launches the worker to poll the database every minute for any pending maillogs
24	21		// that need to be processed.
25	22		func (w *Worker) Start() {
26		-	Logger.Println("Background Worker Started Successfully - Waiting for Campaigns")
	23	+	log.Info("Background Worker Started Successfully - Waiting for Campaigns")
27	24		for t := range time.Tick(1 * time.Minute) {
28	25		ms, err := models.GetQueuedMailLogs(t.UTC())
29	26		if err != nil {
30		-	Logger.Println(err)
	27	+	log.Error(err)
31	28		continue
32	29		}
33	30		// Lock the MailLogs (they will be unlocked after processing)
34	31		err = models.LockMailLogs(ms, true)
35	32		if err != nil {
36		-	Logger.Println(err)
	33	+	log.Error(err)
37	34		continue
38	35		}
39	36		// We'll group the maillogs by campaign ID to (sort of) group
		skipped 11 lines
51	48		uid := msc[0].(*models.MailLog).UserId
52	49		c, err := models.GetCampaign(cid, uid)
53	50		if err != nil {
54		-	Logger.Println(err)
	51	+	log.Error(err)
55	52		errorMail(err, msc)
56	53		return
57	54		}
58	55		if c.Status == models.CAMPAIGN_QUEUED {
59	56		err := c.UpdateStatus(models.CAMPAIGN_IN_PROGRESS)
60	57		if err != nil {
61		-	Logger.Println(err)
	58	+	log.Error(err)
62	59		return
63	60		}
64	61		}
65		-	Logger.Printf("Sending %d maillogs to Mailer", len(msc))
	62	+	log.WithFields(logrus.Fields{
	63	+	"num_emails": len(msc),
	64	+	}).Info("Sending emails to mailer for processing")
66	65		mailer.Mailer.Queue <- msc
67	66		}(cid, msc)
68	67		}
		skipped 4 lines
73	72		func (w *Worker) LaunchCampaign(c models.Campaign) {
74	73		ms, err := models.GetMailLogsByCampaign(c.Id)
75	74		if err != nil {
76		-	Logger.Println(err)
	75	+	log.Error(err)
77	76		return
78	77		}
79	78		models.LockMailLogs(ms, true)
		skipped 25 lines

Moved logging to logrus package. Not perfect yet (still want to update the access logs), but should set the foundation to make better logging in the future.