Skip to content
Snippets Groups Projects
Commit 46b367e7 authored by Jack Zampolin's avatar Jack Zampolin
Browse files

Add tests

parent ddcd99a1
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
plugins/inputs/ghwebhooks/ghwebhooks.go
+ 102
− 130
View file @ 46b367e7
......@@ -4,11 +4,10 @@ import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"sync"
"time"
log "github.com/Sirupsen/logrus"
"github.com/gorilla/mux"
mod "github.com/influxdata/support-tools/ghWebhooks/models"
"github.com/influxdata/telegraf/plugins/inputs"
......@@ -21,12 +20,14 @@ func init() {
type GHWebhooks struct {
ServiceAddress string
MeasurementName string
// Lock for the struct
sync.Mutex
// Events buffer to store events between Gather calls
events []mod.Event
}
// Channel for all incoming events from github
in chan mod.Event
done chan struct{}
func NewGHWebhooks() *GHWebhooks {
return &GHWebhooks{}
}
func (gh *GHWebhooks) SampleConfig() string {
......@@ -34,290 +35,261 @@ func (gh *GHWebhooks) SampleConfig() string {
# Address and port to host Webhook listener on
service_address = ":1618"
# Measurement name
measurement_name = "ghWebhooks"
measurement_name = "ghwebhooks"
`
}
func (gh *GHWebhooks) Description() string {
return "Github Webhook Event collector"
return "A Github Webhook Event collector"
}
// Writes the points from <-gh.in to the Accumulator
func (gh *GHWebhooks) Gather(acc inputs.Accumulator) error {
gh.Lock()
defer gh.Unlock()
for {
select {
case <-gh.done:
return nil
case e := <-gh.in:
p := e.NewPoint()
acc.Add(gh.MeasurementName, p.Fields(), p.Tags(), p.Time())
}
for _, event := range gh.events {
p := event.NewPoint()
acc.AddFields(gh.MeasurementName, p.Fields(), p.Tags(), p.Time())
}
gh.events = make([]mod.Event, 0)
return nil
}
func (gh *GHWebhooks) listen() error {
fmt.Println("in listen!")
func (gh *GHWebhooks) Listen() {
r := mux.NewRouter()
r.HandleFunc("/", gh.webhookHandler).Methods("POST")
err := http.ListenAndServe(fmt.Sprintf(":%s", gh.ServiceAddress), r)
r.HandleFunc("/", gh.eventHandler).Methods("POST")
err := http.ListenAndServe(fmt.Sprintf("%s", gh.ServiceAddress), r)
if err != nil {
return err
log.Printf("Error starting server: %v", err)
}
fmt.Println("Exiting listen")
return nil
}
func (gh *GHWebhooks) Start() error {
fmt.Println("In start function")
gh.done = make(chan struct{})
gh.in = make(chan mod.Event)
// Start the UDP listener
go gh.listen()
// Start the line parser
go gh.Listen()
log.Printf("Started the ghwebhooks service on %s\n", gh.ServiceAddress)
return nil
}
func (gh *GHWebhooks) Stop() {
gh.Lock()
defer gh.Unlock()
log.Println("Stopping the ghWebhooks service")
close(gh.done)
close(gh.in)
}
// Handles the /webhooks route
func (gh *GHWebhooks) webhookHandler(w http.ResponseWriter, r *http.Request) {
fmt.Println("In webhook handler")
// Handles the / route
func (gh *GHWebhooks) eventHandler(w http.ResponseWriter, r *http.Request) {
eventType := r.Header["X-Github-Event"][0]
data, err := ioutil.ReadAll(r.Body)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": eventType, "error": err}
log.WithFields(fields).Fatal("Error reading Github payload")
w.WriteHeader(http.StatusBadRequest)
}
// Send event down chan to GHWebhooks
e := NewEvent(data, eventType)
gh.in <- e
fmt.Printf("%v\n", e.NewPoint())
e, err := NewEvent(data, eventType)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
}
gh.Lock()
gh.events = append(gh.events, e)
gh.Unlock()
w.WriteHeader(http.StatusOK)
}
func newCommitComment(data []byte) mod.Event {
func newCommitComment(data []byte) (mod.Event, error) {
commitCommentStruct := mod.CommitCommentEvent{}
err := json.Unmarshal(data, &commitCommentStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "CommitCommentEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return commitCommentStruct
return commitCommentStruct, nil
}
func newCreate(data []byte) mod.Event {
func newCreate(data []byte) (mod.Event, error) {
createStruct := mod.CreateEvent{}
err := json.Unmarshal(data, &createStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "CreateEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return createStruct
return createStruct, nil
}
func newDelete(data []byte) mod.Event {
func newDelete(data []byte) (mod.Event, error) {
deleteStruct := mod.DeleteEvent{}
err := json.Unmarshal(data, &deleteStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "DeleteEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return deleteStruct
return deleteStruct, nil
}
func newDeployment(data []byte) mod.Event {
func newDeployment(data []byte) (mod.Event, error) {
deploymentStruct := mod.DeploymentEvent{}
err := json.Unmarshal(data, &deploymentStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "DeploymentEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return deploymentStruct
return deploymentStruct, nil
}
func newDeploymentStatus(data []byte) mod.Event {
func newDeploymentStatus(data []byte) (mod.Event, error) {
deploymentStatusStruct := mod.DeploymentStatusEvent{}
err := json.Unmarshal(data, &deploymentStatusStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "DeploymentStatusEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return deploymentStatusStruct
return deploymentStatusStruct, nil
}
func newFork(data []byte) mod.Event {
func newFork(data []byte) (mod.Event, error) {
forkStruct := mod.ForkEvent{}
err := json.Unmarshal(data, &forkStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "ForkEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return forkStruct
return forkStruct, nil
}
func newGollum(data []byte) mod.Event {
func newGollum(data []byte) (mod.Event, error) {
gollumStruct := mod.GollumEvent{}
err := json.Unmarshal(data, &gollumStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "GollumEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return gollumStruct
return gollumStruct, nil
}
func newIssueComment(data []byte) mod.Event {
func newIssueComment(data []byte) (mod.Event, error) {
issueCommentStruct := mod.IssueCommentEvent{}
err := json.Unmarshal(data, &issueCommentStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "IssueCommentEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return issueCommentStruct
return issueCommentStruct, nil
}
func newIssues(data []byte) mod.Event {
func newIssues(data []byte) (mod.Event, error) {
issuesStruct := mod.IssuesEvent{}
err := json.Unmarshal(data, &issuesStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "IssuesEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return issuesStruct
return issuesStruct, nil
}
func newMember(data []byte) mod.Event {
func newMember(data []byte) (mod.Event, error) {
memberStruct := mod.MemberEvent{}
err := json.Unmarshal(data, &memberStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "MemberEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return memberStruct
return memberStruct, nil
}
func newMembership(data []byte) mod.Event {
func newMembership(data []byte) (mod.Event, error) {
membershipStruct := mod.MembershipEvent{}
err := json.Unmarshal(data, &membershipStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "MembershipEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return membershipStruct
return membershipStruct, nil
}
func newPageBuild(data []byte) mod.Event {
func newPageBuild(data []byte) (mod.Event, error) {
pageBuildEvent := mod.PageBuildEvent{}
err := json.Unmarshal(data, &pageBuildEvent)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "PageBuildEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return pageBuildEvent
return pageBuildEvent, nil
}
func newPublic(data []byte) mod.Event {
func newPublic(data []byte) (mod.Event, error) {
publicEvent := mod.PublicEvent{}
err := json.Unmarshal(data, &publicEvent)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "PublicEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return publicEvent
return publicEvent, nil
}
func newPullRequest(data []byte) mod.Event {
func newPullRequest(data []byte) (mod.Event, error) {
pullRequestStruct := mod.PullRequestEvent{}
err := json.Unmarshal(data, &pullRequestStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "PullRequestEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return pullRequestStruct
return pullRequestStruct, nil
}
func newPullRequestReviewComment(data []byte) mod.Event {
func newPullRequestReviewComment(data []byte) (mod.Event, error) {
pullRequestReviewCommentStruct := mod.PullRequestReviewCommentEvent{}
err := json.Unmarshal(data, &pullRequestReviewCommentStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "PullRequestReviewCommentEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return pullRequestReviewCommentStruct
return pullRequestReviewCommentStruct, nil
}
func newPush(data []byte) mod.Event {
func newPush(data []byte) (mod.Event, error) {
pushStruct := mod.PushEvent{}
err := json.Unmarshal(data, &pushStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "PushEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return pushStruct
return pushStruct, nil
}
func newRelease(data []byte) mod.Event {
func newRelease(data []byte) (mod.Event, error) {
releaseStruct := mod.ReleaseEvent{}
err := json.Unmarshal(data, &releaseStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "ReleaseEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return releaseStruct
return releaseStruct, nil
}
func newRepository(data []byte) mod.Event {
func newRepository(data []byte) (mod.Event, error) {
repositoryStruct := mod.RepositoryEvent{}
err := json.Unmarshal(data, &repositoryStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "RepositoryEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return repositoryStruct
return repositoryStruct, nil
}
func newStatus(data []byte) mod.Event {
func newStatus(data []byte) (mod.Event, error) {
statusStruct := mod.StatusEvent{}
err := json.Unmarshal(data, &statusStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "StatusEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return statusStruct
return statusStruct, nil
}
func newTeamAdd(data []byte) mod.Event {
func newTeamAdd(data []byte) (mod.Event, error) {
teamAddStruct := mod.TeamAddEvent{}
err := json.Unmarshal(data, &teamAddStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "TeamAddEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return teamAddStruct
return teamAddStruct, nil
}
func newWatch(data []byte) mod.Event {
func newWatch(data []byte) (mod.Event, error) {
watchStruct := mod.WatchEvent{}
err := json.Unmarshal(data, &watchStruct)
if err != nil {
fields := log.Fields{"time": time.Now(), "event": "WatchEvent", "error": err}
log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
return nil, err
}
return watchStruct
return watchStruct, nil
}
type newEventError struct {
s string
}
func NewEvent(r []byte, t string) mod.Event {
log.WithFields(log.Fields{"event": t, "time": time.Now()}).Info("Event Recieved")
func (e *newEventError) Error() string {
return e.s
}
func NewEvent(r []byte, t string) (mod.Event, error) {
log.Printf("New %v event recieved", t)
switch t {
case "commit_comment":
return newCommitComment(r)
......@@ -362,5 +334,5 @@ func NewEvent(r []byte, t string) mod.Event {
case "watch":
return newWatch(r)
}
return nil
return nil, &newEventError{"Not a recgonized event type"}
}
plugins/inputs/ghwebhooks/ghwebhooks_test.go 0 → 100644
+ 238
− 0
View file @ 46b367e7
package ghwebhooks
import (
"net/http"
"net/http/httptest"
"strings"
"testing"
mod "github.com/influxdata/telegraf/plugins/inputs/ghwebhooks/models"
)
func TestCommitCommentEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.CommitCommentEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "commit_comment")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestDeleteEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.DeleteEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "delete")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestDeploymentEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.DeploymentEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "deployment")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestDeploymentStatusEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.DeploymentStatusEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "deployment_status")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestForkEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.ForkEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "fork")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestGollumEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.GollumEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "gollum")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestIssueCommentEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.IssueCommentEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "issue_comment")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestIssuesEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.IssuesEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "issues")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestMemberEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.MemberEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "member")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestMembershipEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.MembershipEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "membership")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestPageBuildEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.PageBuildEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "page_build")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestPublicEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.PublicEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "public")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestPullRequestReviewCommentEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.PullRequestReviewCommentEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "pull_request_review_comment")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestPushEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.PushEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "push")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestReleaseEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.ReleaseEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "release")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestRepositoryEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.RepositoryEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "repository")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestStatusEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.StatusEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "status")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestTeamAddEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.TeamAddEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "team_add")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
func TestWatchEvent(t *testing.T) {
gh := NewGHWebhooks()
jsonString := mod.Mock{}.WatchEventJSON()
req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
req.Header.Add("X-Github-Event", "watch")
w := httptest.NewRecorder()
gh.eventHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
}
}
plugins/inputs/ghwebhooks/models/mock_json.go 0 → 100644
+ 3561
− 0
View file @ 46b367e7
source diff could not be displayed: it is too large. Options to address this: view the blob.
plugins/inputs/ghwebhooks/models/models.go
+ 45
− 86
View file @ 46b367e7
......@@ -2,16 +2,17 @@ package models
import (
"fmt"
"log"
"time"
log "github.com/Sirupsen/logrus"
"github.com/influxdata/influxdb/client/v2"
)
const Measurement = "ghWebhooks"
const meas = "ghWebhooks"
type Event interface {
NewPoint() *client.Point
JSON() string
}
type Repository struct {
......@@ -106,11 +107,9 @@ func (s CommitCommentEvent) NewPoint() *client.Point {
"commit": s.Comment.Commit,
"comment": s.Comment.Body,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -138,11 +137,9 @@ func (s CreateEvent) NewPoint() *client.Point {
"ref": s.Ref,
"refType": s.RefType,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -170,11 +167,9 @@ func (s DeleteEvent) NewPoint() *client.Point {
"ref": s.Ref,
"refType": s.RefType,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -203,11 +198,9 @@ func (s DeploymentEvent) NewPoint() *client.Point {
"environment": s.Deployment.Environment,
"description": s.Deployment.Description,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -239,11 +232,9 @@ func (s DeploymentStatusEvent) NewPoint() *client.Point {
"depState": s.DeploymentStatus.State,
"depDescription": s.DeploymentStatus.Description,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -269,11 +260,9 @@ func (s ForkEvent) NewPoint() *client.Point {
"issues": s.Repository.Issues,
"fork": s.Forkee.Repository,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -299,11 +288,9 @@ func (s GollumEvent) NewPoint() *client.Point {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -333,11 +320,9 @@ func (s IssueCommentEvent) NewPoint() *client.Point {
"comments": s.Issue.Comments,
"body": s.Comment.Body,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -367,11 +352,9 @@ func (s IssuesEvent) NewPoint() *client.Point {
"title": s.Issue.Title,
"comments": s.Issue.Comments,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -398,11 +381,9 @@ func (s MemberEvent) NewPoint() *client.Point {
"newMember": s.Member.User,
"newMemberStatus": s.Member.Admin,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -426,11 +407,9 @@ func (s MembershipEvent) NewPoint() *client.Point {
"newMember": s.Member.User,
"newMemberStatus": s.Member.Admin,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -454,11 +433,9 @@ func (s PageBuildEvent) NewPoint() *client.Point {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -482,11 +459,9 @@ func (s PublicEvent) NewPoint() *client.Point {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -521,11 +496,9 @@ func (s PullRequestEvent) NewPoint() *client.Point {
"deletions": s.PullRequest.Deletions,
"changedFiles": s.PullRequest.ChangedFiles,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -561,11 +534,9 @@ func (s PullRequestReviewCommentEvent) NewPoint() *client.Point {
"commentFile": s.Comment.File,
"comment": s.Comment.Comment,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -595,11 +566,9 @@ func (s PushEvent) NewPoint() *client.Point {
"Before": s.Before,
"After": s.After,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -625,11 +594,9 @@ func (s ReleaseEvent) NewPoint() *client.Point {
"issues": s.Repository.Issues,
"tagName": s.Release.TagName,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -653,11 +620,9 @@ func (s RepositoryEvent) NewPoint() *client.Point {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -685,11 +650,9 @@ func (s StatusEvent) NewPoint() *client.Point {
"commit": s.Commit,
"state": s.State,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -715,11 +678,9 @@ func (s TeamAddEvent) NewPoint() *client.Point {
"issues": s.Repository.Issues,
"teamName": s.Team.Name,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
......@@ -743,11 +704,9 @@ func (s WatchEvent) NewPoint() *client.Point {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
time := time.Now()
p, err := client.NewPoint(Measurement, t, f, time)
p, err := client.NewPoint(meas, t, f, time.Now())
if err != nil {
i := log.Fields{"event": event, "error": err}
log.WithFields(i).Fatal("Error creating new point...")
log.Fatalf("Failed to create %v event", event)
}
return p
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment