fix extension on windows builds

tighten up permission bits on config file writes

.github/workflows/release-showbridge.yaml

@@ -4,13 +4,45 @@ on:
   push:
     tags:
       - "v*"
+  workflow_dispatch:
 
 permissions:
   contents: write
 
 jobs:
-  goreleaser:
+  setup_release:
     runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.set_version.outputs.version }}
+      short_commit: ${{ steps.set_commit.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: set environment variables
+        run: echo "SHOWBRIDGE_VERSION=${GITHUB_REF_NAME}" >> $GITHUB_ENV
+      - name: clean tag
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: echo "SHOWBRIDGE_VERSION=${SHOWBRIDGE_VERSION#v}" >> $GITHUB_ENV
+      - name: set version
+        id: set_version
+        run: echo "version=${SHOWBRIDGE_VERSION}" >> $GITHUB_OUTPUT
+      - name: set commit
+        id: set_commit
+        run: echo "short_commit=${GITHUB_SHA::7}" >> $GITHUB_OUTPUT
+      - name: create release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          generate_release_notes: true
+  linux_amd64:
+    runs-on: ubuntu-24.04
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
     steps:
       - name: checkout
         uses: actions/checkout@v6
@@ -20,18 +52,166 @@ jobs:
         uses: actions/setup-go@v6
         with:
           go-version-file: "go.mod"
-      - name: release
-        uses: goreleaser/goreleaser-action@v7
+      - name: install alsa lib
+        run: sudo apt-get install -y libasound2-dev
+      - name: build
+        run: |
+          CGO_ENABLED=1 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_linux-amd64.tar.gz showbridge
+      - name: upload linux artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
         with:
-          workdir: cmd/showbridge
-          distribution: goreleaser
-          version: "v2.13.0"
-          args: release --clean
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          name: showbridge-linux-amd64
+          path: |
+            showbridge_*.tar.gz
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
+  linux_arm64:
+    runs-on: ubuntu-24.04-arm
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: "go.mod"
+      - name: install alsa lib
+        run: sudo apt-get install -y libasound2-dev
+      - name: build
+        run: |
+          CGO_ENABLED=1 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_linux-arm64.tar.gz showbridge
+      - name: upload linux artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-linux-arm64
+          path: |
+            showbridge_*.tar.gz
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
+  windows:
+    runs-on: ubuntu-latest
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: "go.mod"
+      - name: setup zig
+        uses: mlugg/setup-zig@v2
+        with:
+          version: 0.16.0
+      - name: build amd64
+        run: |
+          CGO_ENABLED=1 GOOS=windows GOARCH=amd64 CC="zig cc -target x86_64-windows-gnu" CXX="zig c++ -target x86_64-windows-gnu" go build -o showbridge.exe -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          zip showbridge_${SHOWBRIDGE_VERSION}_windows-amd64.zip showbridge.exe
+      - name: build arm64
+        run: |
+          CGO_ENABLED=1 GOOS=windows GOARCH=arm64 CC="zig cc -target aarch64-windows-gnu" CXX="zig c++ -target aarch64-windows-gnu" go build -o showbridge.exe -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          zip showbridge_${SHOWBRIDGE_VERSION}_windows-arm64.zip showbridge.exe
+      - name: upload windows artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-windows
+          path: |
+            showbridge_*.zip
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.zip
+  macos_arm64:
+    runs-on: macos-26
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: "go.mod"
+      - name: build
+        run: |
+          CGO_ENABLED=1 GOOS=darwin GOARCH=arm64 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_macOS-arm64.tar.gz showbridge
+      - name: upload macos artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-macos-arm64
+          path: |
+            showbridge_*.tar.gz
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
+  macos_amd64:
+    runs-on: macos-26-intel
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: "go.mod"
+      - name: build
+        run: |
+          CGO_ENABLED=1 GOOS=darwin GOARCH=amd64 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_macOS-amd64.tar.gz showbridge
+      - name: upload macos artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-macos-amd64
+          path: |
+            showbridge_*.tar.gz
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
   docker:
     runs-on: ubuntu-latest
-    needs: goreleaser
+    needs: linux_amd64
     steps:
       - name: Check out repository
         uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
@@ -57,6 +237,7 @@ jobs:
 
       - name: Build and push
         uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        if: github.ref_type == 'tag'
         with:
           push: true
           context: ./

cmd/showbridge/main.go

@@ -127,6 +127,9 @@ func readConfig(configPath string) (config.Config, error) {
 	}
 
 	validatedConfigBytes, err := json.Marshal(yamlMap)
+	if err != nil {
+		return config.Config{}, err
+	}
 
 	err = json.Unmarshal(validatedConfigBytes, &cfg)
 	if err != nil {
@@ -142,7 +145,7 @@ func writeConfig(configPath string, newConfig config.Config) error {
 		return err
 	}
 
-	err = os.WriteFile(configPath, configBytes, 0644)
+	err = os.WriteFile(configPath, configBytes, 0600)
 	if err != nil {
 		return err
 	}
@@ -156,7 +159,7 @@ func run(ctx context.Context, c *cli.Command) error {
 		return errors.New("config path cannot be empty")
 	}
 
-	logLevel := slog.LevelInfo
+	var logLevel slog.Level
 
 	logLevelFromFlag := c.String("log-level")
 
@@ -260,7 +263,7 @@ func (app *showbridgeApp) handleChannels() {
 				app.routerMutex.Unlock()
 				continue
 			}
-			err, moduleErrors, routeErrors := app.router.UpdateConfig(config, false)
+			moduleErrors, routeErrors, err := app.router.UpdateConfig(config, false)
 			if err != nil {
 				app.logger.Error("failed to update router config", "error", err)
 				app.routerMutex.Unlock()

config.go

@@ -15,9 +15,9 @@ func (r *Router) GetRunningConfig() config.Config {
 	return r.runningConfig
 }
 
-func (r *Router) UpdateConfig(newConfig config.Config, triggerChangeChan bool) (error, []config.ModuleError, []config.RouteError) {
+func (r *Router) UpdateConfig(newConfig config.Config, triggerChangeChan bool) ([]config.ModuleError, []config.RouteError, error) {
 	if !r.runningConfigMu.TryLock() {
-		return errors.New("config update in progress"), nil, nil
+		return nil, nil, errors.New("config update in progress")
 	}
 	defer r.runningConfigMu.Unlock()
 	oldConfig := r.runningConfig
@@ -81,5 +81,5 @@ func (r *Router) UpdateConfig(newConfig config.Config, triggerChangeChan bool) (
 		r.ConfigChange <- newConfig
 	}
 
-	return nil, moduleErrors, routeErrors
+	return moduleErrors, routeErrors, nil
 }

go.mod

@@ -10,8 +10,8 @@ require (
 	github.com/extism/go-sdk v1.7.1
 	github.com/google/jsonschema-go v0.4.3
 	github.com/gorilla/websocket v1.5.3
-	github.com/jwetzell/artnet-go v0.2.1
-	github.com/jwetzell/free-d-go v0.1.0
+	github.com/jwetzell/artnet-go v0.2.2
+	github.com/jwetzell/free-d-go v0.1.1
 	github.com/jwetzell/osc-go v0.3.0
 	github.com/jwetzell/psn-go v0.3.0
 	github.com/nats-io/nats-server/v2 v2.14.0

go.sum

@@ -65,10 +65,10 @@ github.com/ianlancetaylor/demangle v0.0.0-20260505044615-1ff4bf46051f h1:NW3E2QS
 github.com/ianlancetaylor/demangle v0.0.0-20260505044615-1ff4bf46051f/go.mod h1:gx7rwoVhcfuVKG5uya9Hs3Sxj7EIvldVofAWIUtGouw=
 github.com/icholy/digest v1.1.0 h1:HfGg9Irj7i+IX1o1QAmPfIBNu/Q5A5Tu3n/MED9k9H4=
 github.com/icholy/digest v1.1.0/go.mod h1:QNrsSGQ5v7v9cReDI0+eyjsXGUoRSUZQHeQ5C4XLa0Y=
-github.com/jwetzell/artnet-go v0.2.1 h1:iYTKWcwYrF5kBkYfkw2UbWvoueeA23iKEn7fR27mWZE=
-github.com/jwetzell/artnet-go v0.2.1/go.mod h1:gli97Z32a0kMkZ6taoTiK7/lqHcF/dhiGjGJdx/PxqA=
-github.com/jwetzell/free-d-go v0.1.0 h1:xHt6dvyit98X+OC3jVzV0aLidxbyzi3vI9QiYkteEtA=
-github.com/jwetzell/free-d-go v0.1.0/go.mod h1:KmrkooRARRaxJTBSPvwt/6IMAIaHH1R8bSA8cwbbELw=
+github.com/jwetzell/artnet-go v0.2.2 h1:vaXSmRrSlEdETPZ/gvw6aAmVqzQm0i+gfAwyIQkVsB0=
+github.com/jwetzell/artnet-go v0.2.2/go.mod h1:gli97Z32a0kMkZ6taoTiK7/lqHcF/dhiGjGJdx/PxqA=
+github.com/jwetzell/free-d-go v0.1.1 h1:pzY2c4qRxKFBZ2jO3z512ysvUI0BUmgd4mSlWPiFVRM=
+github.com/jwetzell/free-d-go v0.1.1/go.mod h1:KmrkooRARRaxJTBSPvwt/6IMAIaHH1R8bSA8cwbbELw=
 github.com/jwetzell/osc-go v0.3.0 h1:z75TxuQSEmdcmZ56OAepkDa3m88SdZh//3m4nBb/XZI=
 github.com/jwetzell/osc-go v0.3.0/go.mod h1:kCs329JxY6Qjga08tRQ/Gl0PqhgQzLIMpOhm6uszvIc=
 github.com/jwetzell/psn-go v0.3.0 h1:WVpCEmExYE8a+I5hQak5jNJJp2x35VdGX/VuMUKPmhY=

internal/api/api.go

@@ -53,12 +53,16 @@ func (as *ApiServer) Start(config config.ApiConfig) {
 	as.serverMu.Lock()
 	defer as.serverMu.Unlock()
 	as.server = &http.Server{
-		Addr:    fmt.Sprintf(":%d", as.config.Port),
-		Handler: mux,
+		Addr:              fmt.Sprintf(":%d", as.config.Port),
+		ReadHeaderTimeout: 5 * time.Second,
+		Handler:           mux,
 	}
 
 	go func() {
-		as.server.ListenAndServe()
+		err := as.server.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			as.logger.Error("server error", "error", err)
+		}
 		as.shutdown()
 	}()
 }
@@ -148,7 +152,7 @@ func (as *ApiServer) handleConfigHTTP(w http.ResponseWriter, req *http.Request)
 			http.Error(w, "Bad request", http.StatusBadRequest)
 			return
 		}
-		err, moduleErrors, routeErrors := as.configurableRouter.UpdateConfig(newConfig, true)
+		moduleErrors, routeErrors, err := as.configurableRouter.UpdateConfig(newConfig, true)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusConflict)
 			return

internal/common/common.go

@@ -81,11 +81,19 @@ func GetAnyAsByte(value any) (byte, bool) {
 }
 
 func GetAnyAsByteSlice(value any) ([]byte, bool) {
+	// already a []byte
+	byteSlice, ok := value.([]byte)
+	if ok {
+		return byteSlice, true
+	}
+
+	// check for a slice
 	v := reflect.ValueOf(value)
 	if v.Kind() != reflect.Slice {
 		return nil, false
 	}
 
+	// try to convert each element to a byte
 	result := make([]byte, v.Len())
 	for i := 0; i < v.Len(); i++ {
 		elem := v.Index(i).Interface()
@@ -99,6 +107,14 @@ func GetAnyAsByteSlice(value any) ([]byte, bool) {
 }
 
 func GetAnyAsIntSlice(value any) ([]int, bool) {
+
+	// already a []byte
+	intSlice, ok := value.([]int)
+	if ok {
+		return intSlice, true
+	}
+
+	// check for a slice
 	v := reflect.ValueOf(value)
 	if v.Kind() != reflect.Slice {
 		return nil, false

internal/common/module.go

@@ -22,5 +22,5 @@ type KeyValueModule interface {
 }
 
 type DatabaseModule interface {
-	Database() *sql.DB
+	Database() (*sql.DB, error)
 }

internal/config/config.go

@@ -7,6 +7,6 @@ type Config struct {
 }
 
 type Configurable interface {
-	UpdateConfig(newConfig Config, triggerChangeChannel bool) (error, []ModuleError, []RouteError)
+	UpdateConfig(newConfig Config, triggerChangeChannel bool) ([]ModuleError, []RouteError, error)
 	GetRunningConfig() Config
 }

internal/framer/slip.go

@@ -25,9 +25,10 @@ func (sf *SlipFramer) Decode(data []byte) [][]byte {
 		}
 
 		if escapeNext {
-			if packetByte == ESC_END {
+			switch packetByte {
+			case ESC_END:
 				sf.buffer = append(sf.buffer, END)
-			} else if packetByte == ESC_ESC {
+			case ESC_ESC:
 				sf.buffer = append(sf.buffer, ESC)
 			}
 			escapeNext = false

internal/module/db-sqlite.go

@@ -79,6 +79,9 @@ func (t *DbSqlite) Stop() {
 	}
 }
 
-func (t *DbSqlite) Database() *sql.DB {
-	return t.db
+func (t *DbSqlite) Database() (*sql.DB, error) {
+	if t.db == nil {
+		return nil, fmt.Errorf("database not initialized")
+	}
+	return t.db, nil
 }

internal/module/http-server.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log/slog"
 	"net/http"
+	"time"
 
 	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
@@ -163,8 +164,9 @@ func (hs *HTTPServer) Start(ctx context.Context, router common.RouteIO) error {
 	hs.cancel = cancel
 
 	httpServer := &http.Server{
-		Addr:    fmt.Sprintf(":%d", hs.Port),
-		Handler: hs,
+		Addr:              fmt.Sprintf(":%d", hs.Port),
+		ReadHeaderTimeout: 5 * time.Second,
+		Handler:           hs,
 	}
 
 	go func() {

internal/module/serial-client.go

@@ -43,8 +43,13 @@ func init() {
 					Title: "Baud Rate",
 					Type:  "integer",
 				},
+				"framing": {
+					Title: "Framing Method",
+					Type:  "string",
+					Enum:  []any{"LF", "CR", "CRLF", "SLIP", "RAW"},
+				},
 			},
-			Required:             []string{"port", "baudRate"},
+			Required:             []string{"port", "baudRate", "framing"},
 			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
 		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
@@ -91,7 +96,7 @@ func (sc *SerialClient) SetupPort() error {
 
 	port, err := serial.Open(sc.Port, sc.Mode)
 	if err != nil {
-		return fmt.Errorf("serial.client can't open input port: %s", sc.Port)
+		return err
 	}
 
 	sc.port = port
@@ -120,9 +125,12 @@ func (sc *SerialClient) Start(ctx context.Context, router common.RouteIO) error
 		if err != nil {
 			if sc.ctx.Err() != nil {
 				sc.logger.Debug("done")
+				if sc.port != nil {
+					sc.port.Close()
+				}
 				return nil
 			}
-			sc.logger.Error("port setup error", "error", err.Error())
+			sc.logger.Error("port setup error", "port", sc.Port, "error", err.Error())
 			time.Sleep(time.Second * 2)
 			continue
 		}
@@ -131,6 +139,9 @@ func (sc *SerialClient) Start(ctx context.Context, router common.RouteIO) error
 		select {
 		case <-sc.ctx.Done():
 			sc.logger.Debug("done")
+			if sc.port != nil {
+				sc.port.Close()
+			}
 			return nil
 		default:
 		READ:

internal/module/tcp-server.go

@@ -236,7 +236,7 @@ func (ts *TCPServer) Output(ctx context.Context, payload any) error {
 	for _, connection := range ts.connections {
 		_, err := connection.Write(payloadBytes)
 		if err != nil {
-			errorString.WriteString(fmt.Sprintf("%s\n", err.Error()))
+			fmt.Fprintf(&errorString, "%s\n", err.Error())
 		}
 	}
 	ts.connectionsMu.Unlock()

internal/processor/db-query.go

@@ -17,34 +17,43 @@ type DbQuery struct {
 	ModuleId string
 	Query    *template.Template
 	logger   *slog.Logger
+	module   common.DatabaseModule
 }
 
 func (dq *DbQuery) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-	if wrappedPayload.Modules == nil {
-		wrappedPayload.End = true
-		return wrappedPayload, errors.New("db.query wrapped payload has no modules")
+	if dq.module == nil {
+		if wrappedPayload.Modules == nil {
+			wrappedPayload.End = true
+			return wrappedPayload, errors.New("db.query wrapped payload has no modules")
+		}
+
+		module, ok := wrappedPayload.Modules[dq.ModuleId]
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("db.query unable to find module with id: %s", dq.ModuleId)
+		}
+
+		dbModule, ok := module.(common.DatabaseModule)
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("db.query module with id %s is not a DatabaseModule", dq.ModuleId)
+		}
+		dq.module = dbModule
 	}
 
-	module, ok := wrappedPayload.Modules[dq.ModuleId]
-	if !ok {
+	db, err := dq.module.Database()
+	if err != nil {
 		wrappedPayload.End = true
-		return wrappedPayload, fmt.Errorf("db.query unable to find module with id: %s", dq.ModuleId)
+		return wrappedPayload, fmt.Errorf("db.query error getting database from module: %w", err)
 	}
 
-	dbModule, ok := module.(common.DatabaseModule)
-	if !ok {
-		wrappedPayload.End = true
-		return wrappedPayload, fmt.Errorf("db.query module with id %s is not a DatabaseModule", dq.ModuleId)
-	}
-
-	db := dbModule.Database()
 	if db == nil {
 		wrappedPayload.End = true
 		return wrappedPayload, fmt.Errorf("db.query module with id %s returned nil database", dq.ModuleId)
 	}
 
 	var queryBuffer bytes.Buffer
-	err := dq.Query.Execute(&queryBuffer, wrappedPayload)
+	err = dq.Query.Execute(&queryBuffer, wrappedPayload)
 
 	if err != nil {
 		wrappedPayload.End = true
@@ -65,6 +74,7 @@ func (dq *DbQuery) Process(ctx context.Context, wrappedPayload common.WrappedPay
 		return wrappedPayload, fmt.Errorf("db.query error getting columns: %w", err)
 	}
 
+	// TODO(jwetzell): optimize this
 	results := make([]map[string]any, 0)
 
 	for rows.Next() {

internal/processor/kv-get.go

@@ -16,27 +16,31 @@ type KVGet struct {
 	ModuleId string
 	Key      string
 	logger   *slog.Logger
+	module   common.KeyValueModule
 }
 
 func (kvg *KVGet) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-	if wrappedPayload.Modules == nil {
-		wrappedPayload.End = true
-		return wrappedPayload, errors.New("kv.get wrapped payload has no modules")
+	if kvg.module == nil {
+		if wrappedPayload.Modules == nil {
+			wrappedPayload.End = true
+			return wrappedPayload, errors.New("kv.get wrapped payload has no modules")
+		}
+
+		module, ok := wrappedPayload.Modules[kvg.ModuleId]
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("kv.get unable to find module with id: %s", kvg.ModuleId)
+		}
+
+		kvModule, ok := module.(common.KeyValueModule)
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("kv.get module with id %s is not a KeyValueModule", kvg.ModuleId)
+		}
+		kvg.module = kvModule
 	}
 
-	module, ok := wrappedPayload.Modules[kvg.ModuleId]
-	if !ok {
-		wrappedPayload.End = true
-		return wrappedPayload, fmt.Errorf("kv.get unable to find module with id: %s", kvg.ModuleId)
-	}
-
-	kvModule, ok := module.(common.KeyValueModule)
-	if !ok {
-		wrappedPayload.End = true
-		return wrappedPayload, fmt.Errorf("kv.get module with id %s is not a KeyValueModule", kvg.ModuleId)
-	}
-
-	value, err := kvModule.Get(kvg.Key)
+	value, err := kvg.module.Get(kvg.Key)
 	if err != nil {
 		wrappedPayload.End = true
 		return wrappedPayload, fmt.Errorf("kv.get error getting key: %w", err)

internal/processor/kv-set.go

@@ -19,25 +19,28 @@ type KVSet struct {
 	Key      string
 	Value    *template.Template
 	logger   *slog.Logger
+	module   common.KeyValueModule
 }
 
 func (kvs *KVSet) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	if kvs.module == nil {
+		if wrappedPayload.Modules == nil {
+			wrappedPayload.End = true
+			return wrappedPayload, errors.New("kv.set wrapped payload has no modules")
+		}
 
-	if wrappedPayload.Modules == nil {
-		wrappedPayload.End = true
-		return wrappedPayload, errors.New("kv.set wrapped payload has no modules")
-	}
+		module, ok := wrappedPayload.Modules[kvs.ModuleId]
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("kv.set unable to find module with id: %s", kvs.ModuleId)
+		}
 
-	module, ok := wrappedPayload.Modules[kvs.ModuleId]
-	if !ok {
-		wrappedPayload.End = true
-		return wrappedPayload, fmt.Errorf("kv.set unable to find module with id: %s", kvs.ModuleId)
-	}
-
-	kvModule, ok := module.(common.KeyValueModule)
-	if !ok {
-		wrappedPayload.End = true
-		return wrappedPayload, fmt.Errorf("kv.set module with id %s is not a KeyValueModule", kvs.ModuleId)
+		kvModule, ok := module.(common.KeyValueModule)
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("kv.set module with id %s is not a KeyValueModule", kvs.ModuleId)
+		}
+		kvs.module = kvModule
 	}
 
 	var valueBuffer bytes.Buffer
@@ -48,7 +51,7 @@ func (kvs *KVSet) Process(ctx context.Context, wrappedPayload common.WrappedPayl
 		return wrappedPayload, err
 	}
 
-	err = kvModule.Set(kvs.Key, valueBuffer.String())
+	err = kvs.module.Set(kvs.Key, valueBuffer.String())
 	if err != nil {
 		wrappedPayload.End = true
 		return wrappedPayload, fmt.Errorf("kv.set error setting key: %w", err)

internal/processor/midi-control_change-create.go

@@ -35,6 +35,11 @@ func (mccc *MIDIControlChangeCreate) Process(ctx context.Context, wrappedPayload
 
 	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	var controlBuffer bytes.Buffer
 	err = mccc.Control.Execute(&controlBuffer, templateData)
 
@@ -45,6 +50,11 @@ func (mccc *MIDIControlChangeCreate) Process(ctx context.Context, wrappedPayload
 
 	controlValue, err := strconv.ParseUint(controlBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	var valueBuffer bytes.Buffer
 	err = mccc.Value.Execute(&valueBuffer, templateData)
 
@@ -55,6 +65,11 @@ func (mccc *MIDIControlChangeCreate) Process(ctx context.Context, wrappedPayload
 
 	valueValue, err := strconv.ParseUint(valueBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	payloadMessage := midi.ControlChange(uint8(channelValue), uint8(controlValue), uint8(valueValue))
 	wrappedPayload.Payload = payloadMessage
 	return wrappedPayload, nil

internal/processor/midi-note_off-create.go

@@ -35,6 +35,11 @@ func (mnoc *MIDINoteOffCreate) Process(ctx context.Context, wrappedPayload commo
 
 	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	var noteBuffer bytes.Buffer
 	err = mnoc.Note.Execute(&noteBuffer, templateData)
 
@@ -45,6 +50,11 @@ func (mnoc *MIDINoteOffCreate) Process(ctx context.Context, wrappedPayload commo
 
 	noteValue, err := strconv.ParseUint(noteBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	var velocityBuffer bytes.Buffer
 	err = mnoc.Velocity.Execute(&velocityBuffer, templateData)
 
@@ -54,6 +64,12 @@ func (mnoc *MIDINoteOffCreate) Process(ctx context.Context, wrappedPayload commo
 	}
 
 	velocityValue, err := strconv.ParseUint(velocityBuffer.String(), 10, 8)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	payloadMessage := midi.NoteOffVelocity(uint8(channelValue), uint8(noteValue), uint8(velocityValue))
 	wrappedPayload.Payload = payloadMessage
 	return wrappedPayload, nil

internal/processor/midi-note_on-create.go

@@ -35,6 +35,11 @@ func (mnoc *MIDINoteOnCreate) Process(ctx context.Context, wrappedPayload common
 
 	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	var noteBuffer bytes.Buffer
 	err = mnoc.Note.Execute(&noteBuffer, templateData)
 
@@ -45,6 +50,11 @@ func (mnoc *MIDINoteOnCreate) Process(ctx context.Context, wrappedPayload common
 
 	noteValue, err := strconv.ParseUint(noteBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	var velocityBuffer bytes.Buffer
 	err = mnoc.Velocity.Execute(&velocityBuffer, templateData)
 
@@ -54,6 +64,11 @@ func (mnoc *MIDINoteOnCreate) Process(ctx context.Context, wrappedPayload common
 	}
 
 	velocityValue, err := strconv.ParseUint(velocityBuffer.String(), 10, 8)
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	payloadMessage := midi.NoteOn(uint8(channelValue), uint8(noteValue), uint8(velocityValue))
 	wrappedPayload.Payload = payloadMessage
 	return wrappedPayload, nil

internal/processor/midi-program_change-create.go

@@ -34,6 +34,11 @@ func (mpcc *MIDIProgramChangeCreate) Process(ctx context.Context, wrappedPayload
 
 	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	var programBuffer bytes.Buffer
 	err = mpcc.Program.Execute(&programBuffer, templateData)
 
@@ -44,6 +49,11 @@ func (mpcc *MIDIProgramChangeCreate) Process(ctx context.Context, wrappedPayload
 
 	programValue, err := strconv.ParseUint(programBuffer.String(), 10, 8)
 
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
 	payloadMessage := midi.ProgramChange(uint8(channelValue), uint8(programValue))
 	wrappedPayload.Payload = payloadMessage
 	return wrappedPayload, nil

internal/processor/script-js.go

@@ -32,9 +32,13 @@ func (sj *ScriptJS) Process(ctx context.Context, wrappedPayload common.WrappedPa
 		}
 	}
 
-	sj.vm.SetProperty(sj.vm.GlobalObject(), sj.payloadAtom, wrappedPayload.Payload)
+	err := sj.vm.SetProperty(sj.vm.GlobalObject(), sj.payloadAtom, wrappedPayload.Payload)
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
 
-	_, err := sj.vm.Eval(sj.Program, quickjs.EvalGlobal)
+	_, err = sj.vm.Eval(sj.Program, quickjs.EvalGlobal)
 
 	if err != nil {
 		wrappedPayload.End = true

internal/processor/script-wasm.go

@@ -14,7 +14,7 @@ import (
 
 type ScriptWASM struct {
 	config   config.ProcessorConfig
-	Program  *extism.CompiledPlugin
+	Program  *extism.Plugin
 	Function string
 }
 
@@ -28,14 +28,7 @@ func (sw *ScriptWASM) Process(ctx context.Context, wrappedPayload common.Wrapped
 		return wrappedPayload, fmt.Errorf("script.wasm can only process a byte array")
 	}
 
-	program, err := sw.Program.Instance(ctx, extism.PluginInstanceConfig{})
-
-	if err != nil {
-		wrappedPayload.End = true
-		return wrappedPayload, err
-	}
-
-	_, output, err := program.Call(sw.Function, payloadBytes)
+	_, output, err := sw.Program.Call(sw.Function, payloadBytes)
 
 	if err != nil {
 		wrappedPayload.End = true
@@ -117,7 +110,13 @@ func init() {
 				return nil, err
 			}
 
-			return &ScriptWASM{config: processorConfig, Program: program, Function: functionString}, nil
+			programInstance, err := program.Instance(context.Background(), extism.PluginInstanceConfig{})
+
+			if err != nil {
+				return nil, err
+			}
+
+			return &ScriptWASM{config: processorConfig, Program: programInstance, Function: functionString}, nil
 		},
 	})
 }

internal/processor/test/artnet-packet-decode_test.go

@@ -41,7 +41,7 @@ func TestGoodArtnetPacketDecode(t *testing.T) {
 			name:    "number",
 			payload: []byte{65, 114, 116, 45, 78, 101, 116, 0, 0, 80, 0, 14, 237, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 			expected: &artnet.ArtDmx{
-				ID:        []byte{'A', 'r', 't', '-', 'N', 'e', 't', 0x00},
+				ID:        [8]byte{'A', 'r', 't', '-', 'N', 'e', 't', 0x00},
 				OpCode:    artnet.OpDmx,
 				ProtVerHi: 0,
 				ProtVerLo: 14,
@@ -49,7 +49,6 @@ func TestGoodArtnetPacketDecode(t *testing.T) {
 				Physical:  0,
 				SubUni:    1,
 				Net:       0,
-				Length:    512,
 				Data:      make([]uint8, 512),
 			},
 		},
@@ -106,3 +105,15 @@ func TestBadArtnetPacketDecode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkArtnetPacketDecode(b *testing.B) {
+	processorInstance := processor.ArtNetPacketDecode{}
+	payload := []byte{65, 114, 116, 45, 78, 101, 116, 0, 0, 80, 0, 14, 237, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("artnet.packet.decode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/artnet-packet-encode_test.go

@@ -41,7 +41,7 @@ func TestGoodArtnetPacketEncode(t *testing.T) {
 			name:     "number",
 			expected: []byte{65, 114, 116, 45, 78, 101, 116, 0, 0, 80, 0, 14, 237, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 			payload: &artnet.ArtDmx{
-				ID:        []byte{'A', 'r', 't', '-', 'N', 'e', 't', 0x00},
+				ID:        [8]byte{'A', 'r', 't', '-', 'N', 'e', 't', 0x00},
 				OpCode:    artnet.OpDmx,
 				ProtVerHi: 0,
 				ProtVerLo: 14,
@@ -49,7 +49,6 @@ func TestGoodArtnetPacketEncode(t *testing.T) {
 				Physical:  0,
 				SubUni:    1,
 				Net:       0,
-				Length:    512,
 				Data:      make([]uint8, 512),
 			},
 		},
@@ -101,3 +100,25 @@ func TestBadArtnetPacketEncode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkArtnetPacketEncode(b *testing.B) {
+	processorInstance := processor.ArtNetPacketEncode{}
+	payload := &artnet.ArtDmx{
+		ID:        [8]byte{'A', 'r', 't', '-', 'N', 'e', 't', 0x00},
+		OpCode:    artnet.OpDmx,
+		ProtVerHi: 0,
+		ProtVerLo: 14,
+		Sequence:  237,
+		Physical:  0,
+		SubUni:    1,
+		Net:       0,
+		Data:      make([]uint8, 512),
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("artnet.packet.encode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/db-query_test.go

@@ -301,3 +301,32 @@ func TestBadDbQuery(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkDbQuery(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["db.query"]
+	if !ok {
+		b.Fatalf("db.query processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "db.query",
+		Params: map[string]any{
+			"module": "test",
+			"query":  "SELECT * FROM test;",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("db.query failed to create processor: %s", err)
+	}
+	modules := map[string]common.Module{
+		"test": test.NewTestDBModule("test"),
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: nil, Modules: modules})
+		if err != nil {
+			b.Fatalf("db.query processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/debug-log_test.go

@@ -118,3 +118,29 @@ func TestBadDebugLog(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkDebugLog(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["debug.log"]
+	if !ok {
+		b.Fatalf("debug.log processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type:   "debug.log",
+		Params: nil,
+	})
+
+	if err != nil {
+		b.Fatalf("debug.log failed to create processor: %s", err)
+	}
+	modules := map[string]common.Module{}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count, Modules: modules})
+		if err != nil {
+			b.Fatalf("debug.log processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/filter-change_test.go

@@ -124,3 +124,29 @@ func TestBadFilterChange(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFilterChange(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["filter.change"]
+	if !ok {
+		b.Fatalf("filter.change processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type:   "filter.change",
+		Params: nil,
+	})
+
+	if err != nil {
+		b.Fatalf("filter.change failed to create processor: %s", err)
+	}
+	modules := map[string]common.Module{}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count, Modules: modules})
+		if err != nil {
+			b.Fatalf("filter.change processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/filter-expr_test.go

@@ -171,3 +171,30 @@ func TestBadFilterExpr(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFilterExpr(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["filter.expr"]
+	if !ok {
+		b.Fatalf("filter.expr processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "filter.expr",
+		Params: map[string]any{
+			"expression": "Payload % 2 == 0",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("filter.expr failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("filter.expr processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/filter-regex_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/jwetzell/showbridge-go/internal/common"
@@ -173,3 +174,30 @@ func TestBadFilterRegex(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFilterRegex(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["filter.regex"]
+	if !ok {
+		b.Fatalf("filter.regex processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "filter.regex",
+		Params: map[string]any{
+			"pattern": ".*",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("filter.regex failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: fmt.Sprintf("%d", count)})
+		if err != nil {
+			b.Fatalf("filter.regex processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/float-parse_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/jwetzell/showbridge-go/internal/common"
@@ -164,3 +165,28 @@ func TestBadFloatParse(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFloatParse(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["float.parse"]
+	if !ok {
+		b.Fatalf("float.parse processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type:   "float.parse",
+		Params: nil,
+	})
+
+	if err != nil {
+		b.Fatalf("float.parse failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: fmt.Sprintf("%d", count)})
+		if err != nil {
+			b.Fatalf("float.parse processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/float-random_test.go

@@ -184,3 +184,29 @@ func TestBadFloatRandom(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFloatRandom(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["float.random"]
+	if !ok {
+		b.Fatalf("float.random processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "float.random",
+		Params: map[string]any{
+			"min": 0.0,
+			"max": 1.0,
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("float.random failed to create processor: %s", err)
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: nil})
+		if err != nil {
+			b.Fatalf("float.random processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/free-d-create_test.go

@@ -877,3 +877,38 @@ func TestBadFreeDCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFreeDCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["freed.create"]
+	if !ok {
+		b.Fatalf("freed.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "freed.create",
+		Params: map[string]any{
+			"id":    "0",
+			"pan":   "0",
+			"tilt":  "0",
+			"roll":  "0",
+			"posX":  "0",
+			"posY":  "0",
+			"posZ":  "0",
+			"zoom":  "0",
+			"focus": "0",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("freed.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("freed.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/free-d-decode_test.go

@@ -102,3 +102,17 @@ func TestBadFreeDDecode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFreeDDecode(b *testing.B) {
+	processorInstance := processor.FreeDDecode{}
+	payload := []byte{0xd1, 0x01, 0x5a, 0x00, 0x00, 0x2d, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x7f, 0xff, 0x40, 0x7f, 0xff, 0x80, 0x7f, 0xff,
+		0xc0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00, 50,
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("freed.encode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/free-d-encode_test.go

@@ -102,3 +102,25 @@ func TestBadFreeDEncode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkFreeDEncode(b *testing.B) {
+	processorInstance := processor.FreeDEncode{}
+	payload := freeD.FreeDPosition{
+		ID:    1,
+		Pan:   180,
+		Tilt:  90,
+		Roll:  -180,
+		PosX:  131069,
+		PosY:  131070,
+		PosZ:  131071,
+		Zoom:  66051,
+		Focus: 263430,
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("freed.encode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/http-response-create_test.go

@@ -157,3 +157,31 @@ func TestBadHTTPResponseCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkHTTPResponseCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["http.response.create"]
+	if !ok {
+		b.Fatalf("http.response.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "http.response.create",
+		Params: map[string]any{
+			"status":       200,
+			"bodyTemplate": "Hello, {{.Payload}}!",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("http.response.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("http.response.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/int-parse_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/jwetzell/showbridge-go/internal/common"
@@ -198,3 +199,28 @@ func TestBadIntParse(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkIntParse(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["int.parse"]
+	if !ok {
+		b.Fatalf("int.parse processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type:   "int.parse",
+		Params: nil,
+	})
+
+	if err != nil {
+		b.Fatalf("int.parse failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: fmt.Sprintf("%d", count)})
+		if err != nil {
+			b.Fatalf("int.parse processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/int-random_test.go

@@ -195,3 +195,29 @@ func TestBadIntRandom(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkIntRandom(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["int.random"]
+	if !ok {
+		b.Fatalf("int.random processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "int.random",
+		Params: map[string]any{
+			"min": 0,
+			"max": 100,
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("int.random failed to create processor: %s", err)
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: nil})
+		if err != nil {
+			b.Fatalf("int.random processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/int-scale_test.go

@@ -169,3 +169,33 @@ func TestBadIntScale(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkIntScale(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["int.scale"]
+	if !ok {
+		b.Fatalf("int.scale processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "int.scale",
+		Params: map[string]any{
+			"inMin":  0,
+			"inMax":  100,
+			"outMin": 0,
+			"outMax": 127,
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("int.scale failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count % 100})
+		if err != nil {
+			b.Fatalf("int.scale processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/json-decode_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 
@@ -124,3 +125,27 @@ func TestBadJsonDecode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkJsonDecode(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["json.decode"]
+	if !ok {
+		b.Fatalf("json.decode processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "json.decode",
+	})
+
+	if err != nil {
+		b.Fatalf("json.decode failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: []byte(fmt.Sprintf("{\"key\":%d}", count))})
+		if err != nil {
+			b.Fatalf("json.decode processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/json-encode_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"slices"
 	"testing"
 
@@ -113,3 +114,27 @@ func TestBadJsonEncode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkJsonEncode(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["json.encode"]
+	if !ok {
+		b.Fatalf("json.encode processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "json.encode",
+	})
+
+	if err != nil {
+		b.Fatalf("json.encode failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: fmt.Sprintf("{\"key\":%d}", count)})
+		if err != nil {
+			b.Fatalf("json.encode processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/kv-get_test.go

@@ -58,21 +58,10 @@ func TestGoodKvGet(t *testing.T) {
 		expected any
 	}{
 		{
-			name: "basic value",
+			name: "basic key",
 			params: map[string]any{
 				"module": "test",
 				"key":    "test",
-				"value":  "hello",
-			},
-			payload:  "hello",
-			expected: "test",
-		},
-		{
-			name: "template value",
-			params: map[string]any{
-				"module": "test",
-				"key":    "test",
-				"value":  "{{.Payload}}",
 			},
 			payload:  "hello",
 			expected: "test",
@@ -232,3 +221,32 @@ func TestBadKvGet(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkKvGet(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["kv.get"]
+	if !ok {
+		b.Fatalf("kv.get processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "kv.get",
+		Params: map[string]any{
+			"module": "test",
+			"key":    "test",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("kv.get failed to create processor: %s", err)
+	}
+	modules := map[string]common.Module{
+		"test": test.NewTestKVModule("test"),
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: nil, Modules: modules})
+		if err != nil {
+			b.Fatalf("kv.get processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/kv-set_test.go

@@ -281,3 +281,35 @@ func TestBadKvSet(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkKvSet(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["kv.set"]
+	if !ok {
+		b.Fatalf("kv.set processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "kv.set",
+		Params: map[string]any{
+			"module": "test",
+			"key":    "test",
+			"value":  "{{.Payload}}",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("kv.set failed to create processor: %s", err)
+	}
+	modules := map[string]common.Module{
+		"test": test.NewTestKVModule("test"),
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count, Modules: modules})
+		if err != nil {
+			b.Fatalf("kv.set processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/midi-control_change-create_test.go

@@ -159,3 +159,32 @@ func TestBadMIDIControlChangeCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMIDIControlChangeCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["midi.control_change.create"]
+	if !ok {
+		b.Fatalf("midi.control_change.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "midi.control_change.create",
+		Params: map[string]any{
+			"channel": "1",
+			"control": "64",
+			"value":   "127",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("midi.control_change.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("midi.control_change.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/midi-message-decode_test.go

@@ -91,3 +91,15 @@ func TestBadMIDIMessageDecode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMIDIMessageDecode(b *testing.B) {
+	processorInstance := processor.MIDIMessageDecode{}
+	payload := []byte{0x90, 0x40, 0x7F}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("midi.message.decode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/midi-message-encode_test.go

@@ -89,3 +89,15 @@ func TestBadMIDIMessageEncode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMIDIMessageEncode(b *testing.B) {
+	processorInstance := processor.MIDIMessageEncode{}
+	payload := midi.NoteOn(1, 60, 127)
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("midi.message.encode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/midi-message-unpack_test.go

@@ -150,3 +150,15 @@ func TestBadMIDIMessageUnpack(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMIDIMessageUnpack(b *testing.B) {
+	processorInstance := processor.MIDIMessageUnpack{}
+	payload := midi.NoteOn(1, 60, 127)
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("midi.message.unpack processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/midi-note_off-create_test.go

@@ -158,3 +158,32 @@ func TestBadMIDINoteOffCretea(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMIDINoteOffCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["midi.note_off.create"]
+	if !ok {
+		b.Fatalf("midi.note_off.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "midi.note_off.create",
+		Params: map[string]any{
+			"channel":  "1",
+			"note":     "60",
+			"velocity": "100",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("midi.note_off.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("midi.note_off.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/midi-note_on-create_test.go

@@ -155,3 +155,32 @@ func TestBadMIDINoteOnCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMIDINoteOnCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["midi.note_on.create"]
+	if !ok {
+		b.Fatalf("midi.note_on.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "midi.note_on.create",
+		Params: map[string]any{
+			"channel":  "1",
+			"note":     "60",
+			"velocity": "100",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("midi.note_on.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("midi.note_off.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/midi-program_change-create_test.go

@@ -145,3 +145,31 @@ func TestBadMIDIProgramChangeCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMIDIProgramChangeCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["midi.program_change.create"]
+	if !ok {
+		b.Fatalf("midi.program_change.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "midi.program_change.create",
+		Params: map[string]any{
+			"channel": "1",
+			"program": "60",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("midi.program_change.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("midi.program_change.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/mqtt-message-create_test.go

@@ -240,3 +240,33 @@ func TestBadMQTTMessageCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMQTTMessageCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["mqtt.message.create"]
+	if !ok {
+		b.Fatalf("mqtt.message.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "mqtt.message.create",
+		Params: map[string]any{
+			"topic":    "test/topic",
+			"qos":      1,
+			"retained": true,
+			"payload":  "{{.Payload}}",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("mqtt.message.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("mqtt.message.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/nats-message-create_test.go

@@ -208,3 +208,31 @@ func TestBadNATSMessageCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkNATSMessageCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["nats.message.create"]
+	if !ok {
+		b.Fatalf("nats.message.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "nats.message.create",
+		Params: map[string]any{
+			"subject": "test.subject",
+			"payload": "{{.Payload}}",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("nats.message.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("nats.message.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/osc-message-create_test.go

@@ -400,3 +400,32 @@ func TestBadOSCMessageCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkOSCMessageCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["osc.message.create"]
+	if !ok {
+		b.Fatalf("osc.message.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "osc.message.create",
+		Params: map[string]any{
+			"address": "/hello",
+			"args":    []any{"{{.Payload}}"},
+			"types":   "i",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("osc.message.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("osc.message.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/osc-message-decode_test.go

@@ -121,3 +121,15 @@ func TestBadOSCMessageDecode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkOSCMessageDecode(b *testing.B) {
+	processorInstance := processor.OSCMessageDecode{}
+	payload := []byte{47, 116, 101, 115, 116, 0, 0, 0, 44, 105, 0, 0, 0, 0, 0, 42}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("osc.message.decode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/osc-message-encode_test.go

@@ -112,3 +112,23 @@ func TestBadOSCMessageEncode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkOSCMessageEncode(b *testing.B) {
+	processorInstance := processor.OSCMessageEncode{}
+	payload := &osc.OSCMessage{
+		Address: "/test",
+		Args: []osc.OSCArg{
+			{
+				Type:  "i",
+				Value: int32(42),
+			},
+		},
+	}
+
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: payload})
+		if err != nil {
+			b.Fatalf("osc.message.encode processing failed: %s", err)
+		}
+	}
+}

internal/processor/test/script-expr_test.go

@@ -146,3 +146,30 @@ func TestBadScriptExpr(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkScriptExpr(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["script.expr"]
+	if !ok {
+		b.Fatalf("script.expr processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "script.expr",
+		Params: map[string]any{
+			"expression": "Payload % 2",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("script.expr failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("script.expr processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/script-js_test.go

@@ -209,6 +209,13 @@ func TestBadScriptJS(t *testing.T) {
 				Params: test.params,
 			})
 
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("script.js got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
 			got, err := processorInstance.Process(t.Context(), common.WrappedPayload{Payload: test.payload})
 
 			if err == nil {
@@ -221,3 +228,30 @@ func TestBadScriptJS(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkScriptJS(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["script.js"]
+	if !ok {
+		b.Fatalf("script.js processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "script.js",
+		Params: map[string]any{
+			"program": "payload = payload + 1",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("script.js failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("script.js processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/script-wasm_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 
@@ -188,3 +189,30 @@ func TestBadScriptWASM(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkScriptWASM(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["script.wasm"]
+	if !ok {
+		b.Fatalf("script.wasm processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "script.wasm",
+		Params: map[string]any{
+			"path": "good.wasm",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("script.wasm failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: []byte(fmt.Sprintf("%d", count))})
+		if err != nil {
+			b.Fatalf("script.wasm processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/sip-response-audio-create_test.go

@@ -212,3 +212,32 @@ func TestBadSipResponseAudioCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkSipResponseAudioCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["sip.response.audio.create"]
+	if !ok {
+		b.Fatalf("sip.response.audio.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "sip.response.audio.create",
+		Params: map[string]any{
+			"preWait":   0,
+			"audioFile": "good.wav",
+			"postWait":  0,
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("sip.response.audio.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("sip.response.audio.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/sip-response-dtmf-create_test.go

@@ -220,3 +220,32 @@ func TestBadSipResponseDTMFCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkSipResponseDTMFCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["sip.response.dtmf.create"]
+	if !ok {
+		b.Fatalf("sip.response.dtmf.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "sip.response.dtmf.create",
+		Params: map[string]any{
+			"preWait":  0,
+			"digits":   "{{.Payload}}",
+			"postWait": 0,
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("sip.response.dtmf.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("sip.response.dtmf.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/string-create_test.go

@@ -186,3 +186,30 @@ func TestBadStringCreate(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkStringCreate(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["string.create"]
+	if !ok {
+		b.Fatalf("string.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "string.create",
+		Params: map[string]any{
+			"template": "{{.Payload}}",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("string.create failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: count})
+		if err != nil {
+			b.Fatalf("string.create processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/string-decode_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/jwetzell/showbridge-go/internal/common"
@@ -98,3 +99,27 @@ func TestBadStringDecode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkStringDecode(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["string.decode"]
+	if !ok {
+		b.Fatalf("string.decode processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "string.decode",
+	})
+
+	if err != nil {
+		b.Fatalf("string.decode failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: []byte(fmt.Sprintf("%d", count))})
+		if err != nil {
+			b.Fatalf("string.decode processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/string-encode_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"slices"
 	"testing"
 
@@ -104,3 +105,27 @@ func TestBadStringEncode(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkStringEncode(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["string.encode"]
+	if !ok {
+		b.Fatalf("string.encode processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "string.encode",
+	})
+
+	if err != nil {
+		b.Fatalf("string.encode failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: fmt.Sprintf("%d", count)})
+		if err != nil {
+			b.Fatalf("string.encode processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/string-split_test.go

@@ -1,6 +1,7 @@
 package processor_test
 
 import (
+	"fmt"
 	"slices"
 	"testing"
 
@@ -153,3 +154,30 @@ func TestBadStringSplit(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkStringSplit(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["string.split"]
+	if !ok {
+		b.Fatalf("string.split processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "string.split",
+		Params: map[string]any{
+			"separator": ",",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("string.split failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: fmt.Sprintf("%d,%d,%d", count, count, count)})
+		if err != nil {
+			b.Fatalf("string.split processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/struct-field-get_test.go

@@ -191,3 +191,30 @@ func TestBadStructFieldGet(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkStructFieldGet(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["struct.field.get"]
+	if !ok {
+		b.Fatalf("struct.field.get processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "struct.field.get",
+		Params: map[string]any{
+			"name": "Data",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("struct.field.get failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: test.TestStruct{Data: count}})
+		if err != nil {
+			b.Fatalf("struct.field.get processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/processor/test/struct-method-get_test.go

@@ -216,3 +216,30 @@ func TestBadStructMethodGet(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkStructMethodGet(b *testing.B) {
+	registration, ok := processor.ProcessorRegistry["struct.method.get"]
+	if !ok {
+		b.Fatalf("struct.method.get processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "struct.method.get",
+		Params: map[string]any{
+			"name": "GetData",
+		},
+	})
+
+	if err != nil {
+		b.Fatalf("struct.method.get failed to create processor: %s", err)
+	}
+
+	count := 0
+	for b.Loop() {
+		_, err := processorInstance.Process(b.Context(), common.WrappedPayload{Payload: test.TestStruct{Data: count}})
+		if err != nil {
+			b.Fatalf("struct.method.get processing failed: %s", err)
+		}
+		count++
+	}
+}

internal/test/module.go

@@ -79,11 +79,14 @@ func (m *TestDBModule) Start(ctx context.Context, router common.RouteIO) error {
 	return nil
 }
 
-func (m *TestDBModule) Database() *sql.DB {
+func (m *TestDBModule) Database() (*sql.DB, error) {
 	if m.db == nil {
-		db, _ := sql.Open("sqlite", ":memory:")
+		db, err := sql.Open("sqlite", ":memory:")
+		if err != nil {
+			return nil, err
+		}
 
-		db.Exec(`
+		_, err = db.Exec(`
 		CREATE TABLE test (
 			id INTEGER PRIMARY KEY,
 			value TEXT
@@ -91,9 +94,12 @@ func (m *TestDBModule) Database() *sql.DB {
 		INSERT INTO test (id, value) VALUES (1, 'test-1'), (2, 'test-2');
 		
 		`)
+		if err != nil {
+			return nil, err
+		}
 		m.db = db
 	}
-	return m.db
+	return m.db, nil
 }
 
 func (m *TestDBModule) Stop() {}