added basic telemtry tracking WIP (#53)

Author: devbugging

blockchain/projects.go

@@ -23,6 +23,7 @@ import (
 	"fmt"
 	"github.com/dapperlabs/flow-playground-api/model"
 	"github.com/dapperlabs/flow-playground-api/storage"
+	playground "github.com/dapperlabs/flow-playground-api/telemetry"
 
 	"github.com/getsentry/sentry-go"
 	"github.com/google/uuid"
@@ -57,22 +58,27 @@ type Projects struct {
 // Reset the blockchain state.
 func (p *Projects) Reset(project *model.InternalProject) ([]*model.InternalAccount, error) {
 	p.cache.reset(project.ID)
+	playground.Logger().Info("[projects] reset - start")
 
 	err := p.store.ResetProjectState(project)
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] reset - project state reset")
 	accounts, err := p.CreateInitialAccounts(project.ID)
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] reset - accounts created")
 	return accounts, nil
 }
 
 // ExecuteTransaction executes a transaction from the new transaction execution model and persists the execution.
 func (p *Projects) ExecuteTransaction(execution model.NewTransactionExecution) (*model.TransactionExecution, error) {
+	playground.Logger().Info("[projects] execute transaction - start")
+
 	projID := execution.ProjectID
 	p.mutex.load(projID).Lock()
 	defer p.mutex.remove(projID).Unlock()
@@ -81,6 +87,8 @@ func (p *Projects) ExecuteTransaction(execution model.NewTransactionExecution) (
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] execute transaction - emulator loaded")
+
 	signers := make([]flowsdk.Address, len(execution.Signers))
 	for i, sig := range execution.Signers {
 		signers[i] = sig.ToFlowAddress()
@@ -95,12 +103,16 @@ func (p *Projects) ExecuteTransaction(execution model.NewTransactionExecution) (
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] execute transaction - emulator executed")
+
 	exe := model.TransactionExecutionFromFlow(execution.ProjectID, result, tx)
 	err = p.store.InsertTransactionExecution(exe)
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] execute transaction - execution inserted")
+
 	return exe, nil
 }
 
@@ -188,13 +200,17 @@ func (p *Projects) DeployContract(
 	address model.Address,
 	script string,
 ) (*model.Account, error) {
+	playground.Logger().Info("[projects] deploy contract - start")
+
 	p.mutex.load(projectID).Lock()
 	defer p.mutex.remove(projectID).Unlock()
 	emulator, err := p.load(projectID)
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] deploy contract - emulator loaded")
+
 	result, tx, err := emulator.deployContract(address.ToFlowAddress(), script)
 	if err != nil {
 		return nil, err
@@ -203,12 +219,16 @@ func (p *Projects) DeployContract(
 		return nil, result.Error
 	}
 
+	playground.Logger().Info("[projects] deploy contract - contract deployed")
+
 	exe := model.TransactionExecutionFromFlow(projectID, result, tx)
 	err = p.store.InsertTransactionExecution(exe)
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] deploy contract - execution inserted")
+
 	return p.getAccount(projectID, address)
 }
 
@@ -218,11 +238,15 @@ func (p *Projects) getAccount(projectID uuid.UUID, address model.Address) (*mode
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] get account - emulator loaded")
+
 	flowAccount, store, err := emulator.getAccount(address.ToFlowAddress())
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] get account - account retrieved from emualator")
+
 	jsonStorage, err := json.Marshal(store)
 	if err != nil {
 		return nil, errors.Wrap(err, "error marshaling account storage")
@@ -239,12 +263,17 @@ func (p *Projects) getAccount(projectID uuid.UUID, address model.Address) (*mode
 //
 // Do not call this method directly, it is not concurrency safe.
 func (p *Projects) load(projectID uuid.UUID) (blockchain, error) {
+
+	playground.Logger().Info("[projects] load - start")
+
 	var executions []*model.TransactionExecution
 	err := p.store.GetTransactionExecutionsForProject(projectID, &executions)
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[projects] load - retrieve executions")
+
 	emulator, executions, err := p.cache.get(projectID, executions)
 	if emulator == nil || err != nil {
 		emulator, err = newEmulator()
@@ -253,6 +282,8 @@ func (p *Projects) load(projectID uuid.UUID) (blockchain, error) {
 		}
 	}
 
+	playground.Logger().Info("[projects] load - resolve cache")
+
 	for _, execution := range executions {
 		result, _, err := emulator.executeTransaction(
 			execution.Script,
@@ -282,6 +313,8 @@ func (p *Projects) load(projectID uuid.UUID) (blockchain, error) {
 		}
 	}
 
+	playground.Logger().Info("[projects] load - executions completed")
+
 	p.cache.add(projectID, emulator)
 
 	return emulator, nil

controller/accounts.go

@@ -22,6 +22,7 @@ import (
 	"github.com/dapperlabs/flow-playground-api/blockchain"
 	"github.com/dapperlabs/flow-playground-api/model"
 	"github.com/dapperlabs/flow-playground-api/storage"
+	playground "github.com/dapperlabs/flow-playground-api/telemetry"
 	"github.com/google/uuid"
 	"github.com/pkg/errors"
 )
@@ -84,6 +85,7 @@ func (a *Accounts) AllForProjectID(projectID uuid.UUID) ([]*model.Account, error
 
 func (a *Accounts) Update(input model.UpdateAccount) (*model.Account, error) {
 	var acc model.InternalAccount
+	playground.Logger().Info("[accounts.controller] update - start")
 
 	// if we provided draft code then just do a storage update of an account
 	if input.DeployedCode == nil {
@@ -100,19 +102,30 @@ func (a *Accounts) Update(input model.UpdateAccount) (*model.Account, error) {
 		return nil, err
 	}
 
+	playground.Logger().Info("[accounts.controller] update - got account from store")
+
 	account, err := a.blockchain.GetAccount(input.ProjectID, acc.Address)
 	if err != nil {
 		return nil, err
 	}
 
+	playground.Logger().Info("[accounts.controller] update - got account from blockchain")
+
 	if account.DeployedCode != "" {
+		playground.Logger().Info("[accounts.controller] update - redeploying")
+
 		var proj model.InternalProject
 		err := a.store.GetProject(input.ProjectID, &proj)
 		if err != nil {
 			return nil, err
 		}
 
+		playground.Logger().Info("[accounts.controller] update - redeploying, got project from store")
+
 		_, err = a.blockchain.Reset(&proj)
+
+		playground.Logger().Info("[accounts.controller] update - redeploying, reset blockchain")
+
 		if err != nil {
 			return nil, err
 		}
@@ -123,6 +136,8 @@ func (a *Accounts) Update(input model.UpdateAccount) (*model.Account, error) {
 		return nil, errors.Wrap(err, "failed to deploy account code")
 	}
 
+	playground.Logger().Info("[accounts.controller] update - deployed contract on emulator")
+
 	account.DraftCode = acc.DraftCode
 	account.ID = acc.ID
 	return account, nil

resolver.go

@@ -20,8 +20,8 @@ package playground
 
 import (
 	"context"
-
 	"github.com/dapperlabs/flow-playground-api/adapter"
+	"github.com/dapperlabs/flow-playground-api/telemetry"
 
 	"github.com/Masterminds/semver"
 	"github.com/dapperlabs/flow-playground-api/auth"
@@ -109,6 +109,8 @@ func (r *mutationResolver) authorize(ctx context.Context, ID uuid.UUID) error {
 }
 
 func (r *mutationResolver) CreateProject(ctx context.Context, input model.NewProject) (*model.Project, error) {
+	telemetry.Logger().Info("[resolver] create project")
+
 	user, err := r.auth.GetOrCreateUser(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get or create user")
@@ -139,6 +141,8 @@ func (r *mutationResolver) UpdateProject(ctx context.Context, input model.Update
 }
 
 func (r *mutationResolver) UpdateAccount(ctx context.Context, input model.UpdateAccount) (*model.Account, error) {
+	telemetry.Logger().Info("[resolver] update account")
+
 	err := r.authorize(ctx, input.ProjectID)
 	if err != nil {
 		return nil, err
@@ -188,6 +192,8 @@ func (r *mutationResolver) CreateTransactionExecution(
 	ctx context.Context,
 	input model.NewTransactionExecution,
 ) (*model.TransactionExecution, error) {
+	telemetry.Logger().Info("[resolver] create transaction execution")
+
 	err := r.authorize(ctx, input.ProjectID)
 	if err != nil {
 		return nil, err

server/server.go

@@ -21,6 +21,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"github.com/dapperlabs/flow-playground-api/telemetry"
 	"log"
 	"net/http"
 	"strings"
@@ -159,6 +160,8 @@ func main() {
 	logger.Formatter = stackdriver.NewFormatter(stackdriver.WithService("flow-playground"))
 	entry := logrus.NewEntry(logger)
 
+	telemetry.Logger().Info("server startup")
+
 	router.Route("/query", func(r chi.Router) {
 		// Add CORS middleware around every request
 		// See https://github.com/rs/cors for full option listing
@@ -195,6 +198,7 @@ func main() {
 		r.Use(sessions.Middleware(cookieStore))
 		r.Use(monitoring.Middleware())
 
+		telemetry.Logger().Info("GraphQL request")
 		r.Handle(
 			"/",
 			playground.GraphQLHandler(

telemetry/logger.go

@@ -0,0 +1,13 @@
+package telemetry
+
+import "github.com/sirupsen/logrus"
+
+var logger *logrus.Logger
+
+// todo temp telemtry
+func Logger() *logrus.Logger {
+	if logger == nil {
+		logger = logrus.StandardLogger()
+	}
+	return logger
+}