Init Demo App (#7)

This adds initial the services and infrastructure required for the Akita demo

Changes include:
- #2
- #3
- #4

Co-authored-by: Jed Liu <liujed@users.noreply.github.com>

Author: versilis

.gitignore

@@ -17,5 +17,8 @@
 # Dependency directories (remove the comment below to include it)
 # vendor/
 
+# IDE files
+.idea
+
 # Go workspace file
 go.work

Makefile

@@ -0,0 +1,86 @@
+CLIENT_IMAGE ?= akitasoftware/demo-client
+SERVER_IMAGE ?= akitasoftware/demo-server
+CONFIG_FILE ?= application.yml
+TAG ?= latest
+LATEST ?= true
+
+BUILDER=buildx-multi-arch
+
+INFO_COLOR = \033[0;36m
+NO_COLOR   = \033[m
+
+build-client: ## Build the demo client
+	docker build --tag=$(CLIENT_IMAGE):$(TAG) --secret id=application.yml,src=$(CONFIG_FILE) -f client/Dockerfile client
+.PHONY: build-client
+
+build-server: ## Build the demo server
+	docker build --tag=$(SERVER_IMAGE):$(TAG) -f server/Dockerfile server
+.PHONY: build-server
+
+build-images: build-client build-server ## Build the demo images
+
+prepare-buildx: ## Create buildx builder for multi-arch build, if not exists
+	docker buildx inspect $(BUILDER) || docker buildx create --name=$(BUILDER) --driver=docker-container --driver-opt=network=host
+.PHONY: prepare-buildx
+
+# Check if the specified tag exists remotely
+define check_remote_tag
+	@if docker pull $(1):$(TAG) >/dev/null 2>&1; then \
+		echo "Error: Image $(1):$(TAG) already exists in the registry."; \
+		exit 1; \
+	fi
+endef
+
+push-client: prepare-buildx ## Push the demo client image to the registry
+	$(call check_remote_tag,$(CLIENT_IMAGE))
+ifeq ($(LATEST),true)
+	docker buildx build \
+		--push \
+		--builder=$(BUILDER) \
+		--platform=linux/amd64,linux/arm64 \
+		--secret id=application.yml,src=$(CONFIG_FILE) \
+		--build-arg TAG=$(TAG) \
+		--tag=$(CLIENT_IMAGE):$(TAG) \
+		--tag=$(CLIENT_IMAGE):latest \
+		-f client/Dockerfile client
+else
+	docker buildx build \
+		--push \
+		--builder=$(BUILDER) \
+		--platform=linux/amd64,linux/arm64 \
+		--secret id=application.yml,src=$(CONFIG_FILE) \
+		--build-arg TAG=$(TAG) \
+		--tag=$(CLIENT_IMAGE):$(TAG) \
+		-f client/Dockerfile client
+endif
+.PHONY: push-client
+
+push-server: prepare-buildx
+	$(call check_remote_tag,$(SERVER_IMAGE))
+ifeq ($(LATEST),true)
+	docker buildx build \
+		--push \
+		--builder=$(BUILDER) \
+		--platform=linux/amd64,linux/arm64 \
+		--build-arg TAG=$(TAG) \
+		--tag=$(SERVER_IMAGE):$(TAG) \
+		--tag=$(SERVER_IMAGE):latest \
+		-f server/Dockerfile server
+else
+	docker buildx build \
+		--push \
+		--builder=$(BUILDER) \
+		--platform=linux/amd64,linux/arm64 \
+		--build-arg TAG=$(TAG) \
+		--tag=$(SERVER_IMAGE):$(TAG) \
+		-f server/Dockerfile server
+endif
+.PHONY: push-server
+
+push-images: push-client push-server ## Push the demo images to the registry
+.PHONY: push-images
+
+help: ## Show this help
+	@echo Please specify a build target. The choices are:
+	@grep -E '^[0-9a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "$(INFO_COLOR)%-30s$(NO_COLOR) %s\n", $$1, $$2}'
+.PHONY: help

README.md

@@ -1 +1,59 @@
-# demo
+# Akita Demo
+
+This repository hosts the code for demoing the Akita Agent. Before running the demo, please ensure your system meets the following requirements
+
+## Prerequisites
+1. **Docker**: Please ensure that you have Docker isntalled on your machine. You can download it from the official [Docker Website](https://docs.docker.com/engine/install/)
+2. **Akita User Account**: You must have an active user account with Akita. If you don't have one yet, please [sign up here](https://app.akita.software/login?sign_up)
+
+## Getting started
+### Step 1: Obtain Akita API Credentials and Project Name
+Go through initial onboarding in [Akita's web dashboard](https://app.akita.software) and store your API credentials and created project name for later use
+
+### Step 2: Clone the repository
+Clone this repository to your local machine:
+`git clone https://github.com/akitasoftware/akita-demo.git`
+
+### Step 3: Run the demo
+Run the following commands to start the demo:
+```
+chmod +x run.sh
+./run.sh
+```
+
+To stop the demo, run `./stop.sh`. To restart the demo, run `./restart.sh`
+
+## Getting involved
+
+* Please file bugs as issues to this repository.
+* We welcome contributions! If you want to make changes please see our [contributing guide](CONTRIBUTING.md).
+* We're always happy to answer any questions about the Docker extension, or about how you
+  can contribute. Email us at `opensource [at] akitasoftware [dot] com` or
+  [request to join our Slack](https://docs.google.com/forms/d/e/1FAIpQLSfF-Mf4Li_DqysCHy042IBfvtpUDHGYrV6DOHZlJcQV8OIlAA/viewform?usp=sf_link)!
+
+## What is Akita?
+
+Drop-in API monitoring, no code changes necessary.
+
+Built for busy developer teams who don't have time to become experts in monitoring and observability, Akita is the
+fastest, easiest way to see and monitor your API endpoints which makes it possible to quickly track API endpoints and
+their usage in real time.
+
+* **See API endpoints.** Automatically get a searchable map of your API endpoints in use. Explore by latency, errors,
+  and usage. Export as OpenAPI specs.
+* **Get drop-in API monitoring.** Get a drop-in view of volume, latency, and errors, updated in near real-time. Set
+  per-endpoint alerts.
+* **Quickly understand the impact of changes.** Keep track of the endpoints you care about and identify how new
+  deployments impact your endpoints.
+
+Simply drop Akita into your system to understand your system behavior, without having to instrument code or build your
+own dashboards.
+
+[Create an account in the Akita App](https//app.akita.software/login?sign_up) to get started!
+
+## Related links
+* [Akita blog](https://www.akitasoftware.com/blog)
+* [Akita docs](https://docs.akita.software/)
+
+
+

application.yml

@@ -0,0 +1,9 @@
+analytics:
+  enabled: true
+  segment_write_key: <SEGMENT_WRITE_KEY>
+  app:
+    name: aki-demo
+    version: <APP_VERSION>
+  batch_size: 1
+akita:
+  base_url: https://api.akita.software

client/Dockerfile

@@ -0,0 +1,28 @@
+FROM golang:1.19-alpine AS builder
+ENV CGO_ENABLED=0
+
+WORKDIR /app
+
+# Copy go.mod and go.sum files to the workspace
+COPY go.* ./
+# Download all dependencies. Dependencies will be cached if the go.mod and go.sum files are not changed
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    go mod download
+
+COPY . .
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    --mount=type=secret,id=application.yml,dst=./application.yml \
+    go build -trimpath -ldflags="-s -w" -o bin/service
+
+FROM alpine
+
+# Provide the target platform as an environment variable to the application
+ARG TARGETPLATFORM
+ENV TARGETPLATFORM=${TARGETPLATFORM}
+
+COPY --from=builder /app/bin/service /
+
+CMD /service
+

client/app.go

@@ -0,0 +1,115 @@
+package main
+
+import (
+	"akitasoftware.com/demo-client/datasource"
+	"github.com/akitasoftware/akita-libs/analytics"
+	"github.com/akitasoftware/go-utils/optionals"
+	"github.com/golang/glog"
+	"github.com/pkg/errors"
+	"math/rand"
+	"sync"
+	"time"
+)
+
+type App struct {
+	Config *Configuration
+	// The demo server used to generate traffic.
+	DemoServer datasource.DemoServer
+	// The client used to communicate with the Akita backend.
+	AkitaClient datasource.AkitaClient
+	// Client used to send analytics events.
+	AnalyticsClient optionals.Optional[analytics.Client]
+}
+
+// Create a new app instance with the given configuration and demo server.
+func NewApp(config *Configuration, server datasource.DemoServer) *App {
+	return &App{
+		Config:          config,
+		DemoServer:      server,
+		AkitaClient:     config.AkitaClient,
+		AnalyticsClient: config.Analytics,
+	}
+}
+
+// SendEvent sends an analytics event to the Akita backend.
+func (a App) SendEvent(name string, properties map[string]any) {
+	// Add the platform to the properties.
+	properties["platform"] = a.Config.Platform
+
+	analyticsClient, ok := a.AnalyticsClient.Get()
+	if !ok {
+		glog.Warningf("analytics client not configured")
+		return
+	}
+
+	email, err := a.AkitaClient.GetUserEmail(a.Config.Credentials.APIKey, a.Config.Credentials.APISecret)
+	if err != nil {
+		glog.Errorf("failed to get user email: %v", err)
+		return
+	}
+
+	if err := analyticsClient.Track(email, name, properties); err != nil {
+		glog.Errorf("failed to emit analytics event: %v", err)
+	}
+}
+
+// HandleDemoTasks sends requests to the demo server at a regular interval.
+func (a App) HandleDemoTasks() {
+	requestInterval := time.Second
+
+	// Create a ticker that fires every second.
+	ticker := time.NewTicker(requestInterval)
+	// Mutex for keeping track of errors logged by the ticker.
+	var rwMutex sync.RWMutex
+	var errorCount int
+
+	for {
+		select {
+		case <-ticker.C:
+			go func() {
+				// Send a request to the demo server.
+				err := a.sendMockTraffic()
+
+				// Send an error event if we've sent less than 5 error events
+				// TODO: It would be nice to have the error count be configurable.
+				// We could also consider resetting the error count after a certain amount of time.
+				rwMutex.RLock()
+				if err != nil && errorCount < 5 {
+					a.SendEvent(
+						"Demo Client Error", map[string]any{
+							"error": err.Error(),
+						},
+					)
+					// Increment the error count. This is protected by a mutex because we're in a goroutine.
+					rwMutex.RUnlock()
+					rwMutex.Lock()
+					errorCount++
+					rwMutex.Unlock()
+				}
+			}()
+		}
+	}
+}
+
+// Send a random request to the demo server.
+func (a App) sendMockTraffic() error {
+	var err error
+
+	// To showcase response count metric, we should attempt to send request disproportionately
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	randomNumber := r.Intn(100)
+	if randomNumber < 10 {
+		err = a.DemoServer.GetOwner()
+	} else if randomNumber < 67 {
+		err = a.DemoServer.GetBreed()
+	} else {
+		err = a.DemoServer.PostTrick()
+	}
+
+	if err != nil {
+		return errors.Wrap(err, "failed to send mock traffic")
+	}
+
+	return nil
+}

client/config.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"akitasoftware.com/demo-client/datasource"
+	_ "embed"
+	"fmt"
+	"github.com/akitasoftware/akita-libs/analytics"
+	"github.com/akitasoftware/go-utils/optionals"
+	"github.com/golang/glog"
+	"gopkg.in/yaml.v3"
+	"net/http"
+	"os"
+)
+
+type rawConfiguration struct {
+	Analytics struct {
+		// Configures the analytics client.
+		analytics.Config `yaml:",inline"`
+		// Whether analytics are enabled.
+		Enabled bool `yaml:"enabled"`
+	} `yaml:"analytics"`
+	Akita struct {
+		// Base URL of the Akita API.
+		BaseURL string `yaml:"base_url"`
+	} `yaml:"akita"`
+}
+
+type UserCredentials struct {
+	// The credentials used to identify the user.
+	APIKey    string
+	APISecret string
+}
+
+type Configuration struct {
+	AkitaClient datasource.AkitaClient
+	Analytics   optionals.Optional[analytics.Client]
+	Credentials UserCredentials
+	// The target platform for the Docker image the client is derived from.
+	Platform string
+}
+
+// Takes a byte array containing a rawConfiguration and turns it into a
+// Configuration instance.
+func ParseConfiguration(rawData []byte) (*Configuration, error) {
+	var rawConfig rawConfiguration
+	if err := yaml.Unmarshal(rawData, &rawConfig); err != nil {
+		return nil, fmt.Errorf("failed to parse configuration: %w", err)
+	}
+
+	// Create the Akita client.
+	akitaClient := datasource.NewAkitaClient(rawConfig.Akita.BaseURL, http.DefaultClient)
+
+	// Create the analytics client.
+	var analyticsClient optionals.Optional[analytics.Client]
+	if rawConfig.Analytics.Enabled {
+		glog.Infof("Enabling analytics...")
+		client, err := analytics.NewClient(rawConfig.Analytics.Config)
+		if err != nil {
+			// If we fail to create the analytics client, we don't want to fail the entire demo.
+			// Instead, we just log the error and continue without analytics.
+			glog.Errorf("Failed to create analytics client: %v", err)
+		}
+
+		glog.Infof("Analytics client created successfully")
+		analyticsClient = optionals.Some(client)
+	} else {
+		glog.Infof("Analytics have been disabled")
+	}
+
+	return &Configuration{
+		AkitaClient: akitaClient,
+		Analytics:   analyticsClient,
+		Credentials: UserCredentials{
+			// The API key and secret are set by the Docker Compose file.
+			APIKey:    os.Getenv("AKITA_API_KEY_ID"),
+			APISecret: os.Getenv("AKITA_API_KEY_SECRET"),
+		},
+		// Get the target platform declared at build time.
+		Platform: os.Getenv("TARGETPLATFORM"),
+	}, nil
+}