diff --git a/ee/tables/crowdstrike/falcon_kernel_check/table.go b/ee/tables/crowdstrike/falcon_kernel_check/table.go
index 6c9e8ad9b..ac12f3055 100644
--- a/ee/tables/crowdstrike/falcon_kernel_check/table.go
+++ b/ee/tables/crowdstrike/falcon_kernel_check/table.go
@@ -6,20 +6,21 @@ package falcon_kernel_check
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"regexp"
 
 	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
 	"github.com/osquery/osquery-go/plugin/table"
 )
 
 type Table struct {
-	logger log.Logger
+	slogger *slog.Logger
+	logger  log.Logger // preserved only for temporary use in tablehelpers.Exec
 }
 
-func TablePlugin(logger log.Logger) *table.Plugin {
+func TablePlugin(slogger *slog.Logger, logger log.Logger) *table.Plugin {
 	columns := []table.ColumnDefinition{
 		table.TextColumn("kernel"),
 		table.IntegerColumn("supported"),
@@ -29,7 +30,8 @@ func TablePlugin(logger log.Logger) *table.Plugin {
 	tableName := "kolide_falcon_kernel_check"
 
 	t := &Table{
-		logger: log.With(logger, "table", tableName),
+		slogger: slogger.With("table", tableName),
+		logger:  log.With(logger, "table", tableName),
 	}
 
 	return table.NewPlugin(tableName, columns, t.generate)
@@ -38,13 +40,19 @@ func TablePlugin(logger log.Logger) *table.Plugin {
 func (t *Table) generate(ctx context.Context, queryContext table.QueryContext) ([]map[string]string, error) {
 	output, err := tablehelpers.Exec(ctx, t.logger, 5, allowedcmd.FalconKernelCheck, []string{}, false)
 	if err != nil {
-		level.Info(t.logger).Log("msg", "exec failed", "err", err)
+		t.slogger.Log(ctx, slog.LevelInfo,
+			"exec failed",
+			"err", err,
+		)
 		return nil, err
 	}
 
 	status, err := parseStatus(string(output))
 	if err != nil {
-		level.Info(t.logger).Log("msg", "Error parsing exec status", "err", err)
+		t.slogger.Log(ctx, slog.LevelInfo,
+			"error parsing exec status",
+			"err", err,
+		)
 		return nil, err
 	}
 
diff --git a/ee/tables/crowdstrike/falconctl/table.go b/ee/tables/crowdstrike/falconctl/table.go
index e7bfdfd54..1153bf03b 100644
--- a/ee/tables/crowdstrike/falconctl/table.go
+++ b/ee/tables/crowdstrike/falconctl/table.go
@@ -7,10 +7,10 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"log/slog"
 	"strings"
 
 	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/dataflatten"
 	"github.com/kolide/launcher/ee/tables/dataflattentable"
@@ -42,17 +42,19 @@ var (
 type execFunc func(context.Context, log.Logger, int, allowedcmd.AllowedCommand, []string, bool) ([]byte, error)
 
 type falconctlOptionsTable struct {
-	logger    log.Logger
+	slogger   *slog.Logger
+	logger    log.Logger // preserved temporarily for use in dataflattentables/tablehelpers
 	tableName string
 	execFunc  execFunc
 }
 
-func NewFalconctlOptionTable(logger log.Logger) *table.Plugin {
+func NewFalconctlOptionTable(slogger *slog.Logger, logger log.Logger) *table.Plugin {
 	columns := dataflattentable.Columns(
 		table.TextColumn("options"),
 	)
 
 	t := &falconctlOptionsTable{
+		slogger:   slogger.With("table", "kolide_falconctl_options"),
 		logger:    log.With(logger, "table", "kolide_falconctl_options"),
 		tableName: "kolide_falconctl_options",
 		execFunc:  tablehelpers.Exec,
@@ -79,7 +81,10 @@ OUTER:
 		for _, option := range options {
 			option = strings.Trim(option, " ")
 			if !optionAllowed(option) {
-				level.Info(t.logger).Log("msg", "requested option not allowed", "option", option)
+				t.slogger.Log(ctx, slog.LevelInfo,
+					"requested option not allowed",
+					"option", option,
+				)
 				continue OUTER
 			}
 		}
@@ -92,14 +97,20 @@ OUTER:
 
 		output, err := t.execFunc(ctx, t.logger, 30, allowedcmd.Falconctl, args, false)
 		if err != nil {
-			level.Info(t.logger).Log("msg", "exec failed", "err", err)
+			t.slogger.Log(ctx, slog.LevelInfo,
+				"exec failed",
+				"err", err,
+			)
 			synthesizedData := map[string]string{
 				"_error": fmt.Sprintf("falconctl parse failure: %s", err),
 			}
 
 			flattened, err := dataflatten.Flatten(synthesizedData)
 			if err != nil {
-				level.Info(t.logger).Log("msg", "failure flattening output", "err", err)
+				t.slogger.Log(ctx, slog.LevelInfo,
+					"failure flattening output",
+					"err", err,
+				)
 				continue
 			}
 
@@ -109,7 +120,10 @@ OUTER:
 
 		parsed, err := parseOptions(bytes.NewReader(output))
 		if err != nil {
-			level.Info(t.logger).Log("msg", "parse failed", "err", err)
+			t.slogger.Log(ctx, slog.LevelInfo,
+				"parse failed",
+				"err", err,
+			)
 			parsed = map[string]string{
 				"_error": fmt.Sprintf("falconctl parse failure: %s", err),
 			}
@@ -123,7 +137,10 @@ OUTER:
 
 			flattened, err := dataflatten.Flatten(parsed, flattenOpts...)
 			if err != nil {
-				level.Info(t.logger).Log("msg", "failure flattening output", "err", err)
+				t.slogger.Log(ctx, slog.LevelInfo,
+					"failure flattening output",
+					"err", err,
+				)
 				continue
 			}
 
diff --git a/ee/tables/crowdstrike/falconctl/table_test.go b/ee/tables/crowdstrike/falconctl/table_test.go
index e1f58971b..ba59cb866 100644
--- a/ee/tables/crowdstrike/falconctl/table_test.go
+++ b/ee/tables/crowdstrike/falconctl/table_test.go
@@ -4,14 +4,16 @@
 package falconctl
 
 import (
-	"bytes"
 	"context"
+	"log/slog"
 	"strings"
 	"testing"
 
 	"github.com/go-kit/kit/log"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
+	"github.com/kolide/launcher/pkg/log/multislogger"
+	"github.com/kolide/launcher/pkg/threadsafebuffer"
 	"github.com/stretchr/testify/require"
 )
 
@@ -62,9 +64,10 @@ func TestOptionRestrictions(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			var logBytes bytes.Buffer
+			var logBytes threadsafebuffer.ThreadSafeBuffer
 
 			testTable := &falconctlOptionsTable{
+				slogger:  multislogger.New(slog.NewJSONHandler(&logBytes, &slog.HandlerOptions{Level: slog.LevelDebug})).Logger,
 				logger:   log.NewLogfmtLogger(&logBytes),
 				execFunc: noopExec,
 			}
diff --git a/ee/tables/cryptsetup/table.go b/ee/tables/cryptsetup/table.go
index 7554bc2d8..ad08bb8b5 100644
--- a/ee/tables/cryptsetup/table.go
+++ b/ee/tables/cryptsetup/table.go
@@ -6,10 +6,10 @@ package cryptsetup
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"strings"
 
 	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/dataflatten"
 	"github.com/kolide/launcher/ee/tables/dataflattentable"
@@ -20,18 +20,20 @@ import (
 const allowedNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-/_"
 
 type Table struct {
-	logger log.Logger
-	name   string
+	slogger *slog.Logger
+	logger  log.Logger // preserved only for use in dataflattentable/tablehelpers.Exec temporarily
+	name    string
 }
 
-func TablePlugin(logger log.Logger) *table.Plugin {
+func TablePlugin(slogger *slog.Logger, logger log.Logger) *table.Plugin {
 	columns := dataflattentable.Columns(
 		table.TextColumn("name"),
 	)
 
 	t := &Table{
-		logger: logger,
-		name:   "kolide_cryptsetup_status",
+		slogger: slogger.With("table", "kolide_cryptsetup_status"),
+		logger:  logger,
+		name:    "kolide_cryptsetup_status",
 	}
 
 	return table.NewPlugin(t.name, columns, t.generate)
@@ -52,20 +54,31 @@ func (t *Table) generate(ctx context.Context, queryContext table.QueryContext) (
 	for _, name := range requestedNames {
 		output, err := tablehelpers.Exec(ctx, t.logger, 15, allowedcmd.Cryptsetup, []string{"--readonly", "status", name}, false)
 		if err != nil {
-			level.Debug(t.logger).Log("msg", "Error execing for status", "name", name, "err", err)
+			t.slogger.Log(ctx, slog.LevelDebug,
+				"error execing for status",
+				"name", name,
+				"err", err,
+			)
 			continue
 		}
 
 		status, err := parseStatus(output)
 		if err != nil {
-			level.Info(t.logger).Log("msg", "Error parsing status", "name", name, "err", err)
+			t.slogger.Log(ctx, slog.LevelInfo,
+				"error parsing status",
+				"name", name,
+				"err", err,
+			)
 			continue
 		}
 
 		for _, dataQuery := range tablehelpers.GetConstraints(queryContext, "query", tablehelpers.WithDefaults("*")) {
 			flatData, err := t.flattenOutput(dataQuery, status)
 			if err != nil {
-				level.Info(t.logger).Log("msg", "flatten failed", "err", err)
+				t.slogger.Log(ctx, slog.LevelInfo,
+					"flatten failed",
+					"err", err,
+				)
 				continue
 			}
 
diff --git a/ee/tables/fscrypt_info/generate.go b/ee/tables/fscrypt_info/generate.go
index 8a7a74c6f..6e7fe2c24 100644
--- a/ee/tables/fscrypt_info/generate.go
+++ b/ee/tables/fscrypt_info/generate.go
@@ -6,16 +6,14 @@ package fscrypt_info
 import (
 	"context"
 	"errors"
-	"runtime"
+	"log/slog"
 
-	"github.com/go-kit/kit/log/level"
 	"github.com/osquery/osquery-go/plugin/table"
 )
 
 func (t *Table) generate(ctx context.Context, queryContext table.QueryContext) ([]map[string]string, error) {
-	level.Info(t.logger).Log(
-		"msg", tableName+" is only supported on linux",
-		"goos", runtime.GOOS,
+	t.slogger.Log(ctx, slog.LevelInfo,
+		"table only supported on linux",
 	)
 	return nil, errors.New("Platform Unsupported")
 }
diff --git a/ee/tables/fscrypt_info/generate_linux.go b/ee/tables/fscrypt_info/generate_linux.go
index 8af4271d6..4632362c3 100644
--- a/ee/tables/fscrypt_info/generate_linux.go
+++ b/ee/tables/fscrypt_info/generate_linux.go
@@ -6,8 +6,8 @@ package fscrypt_info
 import (
 	"context"
 	"errors"
+	"log/slog"
 
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
 	"github.com/osquery/osquery-go/plugin/table"
 )
@@ -27,8 +27,8 @@ func (t *Table) generate(ctx context.Context, queryContext table.QueryContext) (
 	for i, dirpath := range paths {
 		info, err := GetInfo(dirpath)
 		if err != nil {
-			level.Info(t.logger).Log(
-				"msg", "error getting fscrypt info",
+			t.slogger.Log(ctx, slog.LevelInfo,
+				"error getting fscrypt info",
 				"path", dirpath,
 				"err", err,
 			)
diff --git a/ee/tables/fscrypt_info/table.go b/ee/tables/fscrypt_info/table.go
index d2db09235..093be05e5 100644
--- a/ee/tables/fscrypt_info/table.go
+++ b/ee/tables/fscrypt_info/table.go
@@ -1,7 +1,8 @@
 package fscrypt_info
 
 import (
-	"github.com/go-kit/kit/log"
+	"log/slog"
+
 	"github.com/osquery/osquery-go/plugin/table"
 )
 
@@ -10,10 +11,10 @@ const (
 )
 
 type Table struct {
-	logger log.Logger
+	slogger *slog.Logger
 }
 
-func TablePlugin(logger log.Logger) *table.Plugin {
+func TablePlugin(slogger *slog.Logger) *table.Plugin {
 	columns := []table.ColumnDefinition{
 		table.TextColumn("path"),
 		table.IntegerColumn("encrypted"),
@@ -26,7 +27,7 @@ func TablePlugin(logger log.Logger) *table.Plugin {
 	}
 
 	t := &Table{
-		logger: logger,
+		slogger: slogger.With("table", tableName),
 	}
 	return table.NewPlugin(tableName, columns, t.generate)
 }
diff --git a/ee/tables/gsettings/gsettings.go b/ee/tables/gsettings/gsettings.go
index 2e4154973..7c0840e76 100644
--- a/ee/tables/gsettings/gsettings.go
+++ b/ee/tables/gsettings/gsettings.go
@@ -10,6 +10,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
 	"os/user"
 	"strconv"
@@ -17,8 +18,6 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/agent"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
@@ -30,13 +29,13 @@ const allowedCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0
 type gsettingsExecer func(ctx context.Context, username string, buf *bytes.Buffer) error
 
 type GsettingsValues struct {
-	logger   log.Logger
+	slogger  *slog.Logger
 	getBytes gsettingsExecer
 }
 
 // Settings returns a table plugin for querying setting values from the
 // gsettings command.
-func Settings(logger log.Logger) *table.Plugin {
+func Settings(slogger *slog.Logger) *table.Plugin {
 	columns := []table.ColumnDefinition{
 		table.TextColumn("schema"),
 		table.TextColumn("key"),
@@ -45,7 +44,7 @@ func Settings(logger log.Logger) *table.Plugin {
 	}
 
 	t := &GsettingsValues{
-		logger:   logger,
+		slogger:  slogger.With("table", "kolide_gsettings"),
 		getBytes: execGsettings,
 	}
 
@@ -64,15 +63,15 @@ func (t *GsettingsValues) generate(ctx context.Context, queryContext table.Query
 
 		err := t.getBytes(ctx, username, &output)
 		if err != nil {
-			level.Info(t.logger).Log(
-				"msg", "error getting bytes for user",
+			t.slogger.Log(ctx, slog.LevelInfo,
+				"error getting bytes for user",
 				"username", username,
 				"err", err,
 			)
 			continue
 		}
 
-		user_results := t.parse(username, &output)
+		user_results := t.parse(ctx, username, &output)
 		results = append(results, user_results...)
 	}
 
@@ -146,7 +145,7 @@ func execGsettings(ctx context.Context, username string, buf *bytes.Buffer) erro
 	return nil
 }
 
-func (t *GsettingsValues) parse(username string, input io.Reader) []map[string]string {
+func (t *GsettingsValues) parse(ctx context.Context, username string, input io.Reader) []map[string]string {
 	var results []map[string]string
 
 	scanner := bufio.NewScanner(input)
@@ -159,8 +158,8 @@ func (t *GsettingsValues) parse(username string, input io.Reader) []map[string]s
 
 		parts := strings.SplitN(line, " ", 3)
 		if len(parts) < 3 {
-			level.Error(t.logger).Log(
-				"msg", "unable to process line, not enough segments",
+			t.slogger.Log(ctx, slog.LevelError,
+				"unable to process line, not enough segments",
 				"line", line,
 			)
 			continue
@@ -175,7 +174,10 @@ func (t *GsettingsValues) parse(username string, input io.Reader) []map[string]s
 	}
 
 	if err := scanner.Err(); err != nil {
-		level.Debug(t.logger).Log("msg", "scanner error", "err", err)
+		t.slogger.Log(ctx, slog.LevelDebug,
+			"scanner error",
+			"err", err,
+		)
 	}
 
 	return results
diff --git a/ee/tables/gsettings/gsettings_test.go b/ee/tables/gsettings/gsettings_test.go
index b2802e5f6..83934e35a 100644
--- a/ee/tables/gsettings/gsettings_test.go
+++ b/ee/tables/gsettings/gsettings_test.go
@@ -10,8 +10,8 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/go-kit/kit/log"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 	"github.com/stretchr/testify/require"
 )
 
@@ -48,7 +48,7 @@ func TestGsettingsValues(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		table := GsettingsValues{
-			logger: log.NewNopLogger(),
+			slogger: multislogger.New().Logger,
 			getBytes: func(ctx context.Context, username string, buf *bytes.Buffer) error {
 				f, err := os.Open(filepath.Join("testdata", tt.filename))
 				require.NoError(t, err, "opening file %s", tt.filename)
@@ -127,7 +127,7 @@ func TestPerUser(t *testing.T) {
 
 	for _, tt := range tests {
 		table := GsettingsValues{
-			logger:   log.NewNopLogger(),
+			slogger:  multislogger.New().Logger,
 			getBytes: execGsettings,
 		}
 		mockQC := tablehelpers.MockQueryContext(map[string][]string{
@@ -171,7 +171,7 @@ func TestListKeys(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		table := GsettingsMetadata{
-			logger: log.NewNopLogger(),
+			slogger: multislogger.New().Logger,
 			cmdRunner: func(ctx context.Context, args []string, tmpdir string, buf *bytes.Buffer) error {
 				f, err := os.Open(filepath.Join("testdata", tt.filename))
 				require.NoError(t, err, "opening file %s", tt.filename)
@@ -225,7 +225,7 @@ func TestGetType(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		table := GsettingsMetadata{
-			logger: log.NewNopLogger(),
+			slogger: multislogger.New().Logger,
 			cmdRunner: func(ctx context.Context, args []string, tmpdir string, buf *bytes.Buffer) error {
 				_, err := buf.WriteString(tt.input)
 				require.NoError(t, err)
diff --git a/ee/tables/gsettings/metadata.go b/ee/tables/gsettings/metadata.go
index 01d6c759e..d38d5e1fa 100644
--- a/ee/tables/gsettings/metadata.go
+++ b/ee/tables/gsettings/metadata.go
@@ -9,12 +9,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"strings"
 	"time"
 
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/agent"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
@@ -22,13 +21,13 @@ import (
 )
 
 type GsettingsMetadata struct {
-	logger    log.Logger
+	slogger   *slog.Logger
 	cmdRunner func(ctx context.Context, args []string, tmpdir string, output *bytes.Buffer) error
 }
 
 // Metadata returns a table plugin for querying metadata about specific keys in
 // specific schemas
-func Metadata(logger log.Logger) *table.Plugin {
+func Metadata(slogger *slog.Logger) *table.Plugin {
 	columns := []table.ColumnDefinition{
 		// TODO: maybe need to add 'path' for relocatable schemas..
 		table.TextColumn("schema"),
@@ -38,7 +37,7 @@ func Metadata(logger log.Logger) *table.Plugin {
 	}
 
 	t := &GsettingsMetadata{
-		logger:    logger,
+		slogger:   slogger.With("table", "kolide_gsettings_metadata"),
 		cmdRunner: execGsettingsCommand,
 	}
 
@@ -56,8 +55,8 @@ func (t *GsettingsMetadata) generate(ctx context.Context, queryContext table.Que
 	for _, schema := range schemas {
 		descriptions, err := t.gsettingsDescribeForSchema(ctx, schema)
 		if err != nil {
-			level.Info(t.logger).Log(
-				"msg", "error describing keys for schema",
+			t.slogger.Log(ctx, slog.LevelInfo,
+				"error describing keys for schema",
 				"schema", schema,
 				"err", err,
 			)
@@ -105,8 +104,8 @@ func (t *GsettingsMetadata) gsettingsDescribeForSchema(ctx context.Context, sche
 	for _, k := range keys {
 		desc, err := t.describeKey(ctx, schema, k, dir)
 		if err != nil {
-			level.Info(t.logger).Log(
-				"msg", "error describing key",
+			t.slogger.Log(ctx, slog.LevelInfo,
+				"error describing key",
 				"key", k,
 				"schema", schema,
 				"err", err,
@@ -139,7 +138,10 @@ func (t *GsettingsMetadata) listKeys(ctx context.Context, schema, tmpdir string)
 	}
 
 	if err := scanner.Err(); err != nil {
-		level.Info(t.logger).Log("msg", "scanner error", "err", err)
+		t.slogger.Log(ctx, slog.LevelInfo,
+			"scanner error",
+			"err", err,
+		)
 	}
 
 	return keys, nil
diff --git a/ee/tables/nix_env/upgradeable/upgradeable.go b/ee/tables/nix_env/upgradeable/upgradeable.go
index 542c971f2..c73865f2c 100644
--- a/ee/tables/nix_env/upgradeable/upgradeable.go
+++ b/ee/tables/nix_env/upgradeable/upgradeable.go
@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"os/exec"
 	"os/user"
 	"strconv"
@@ -14,7 +15,6 @@ import (
 	"syscall"
 
 	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/dataflatten"
 	"github.com/kolide/launcher/ee/tables/dataflattentable"
@@ -25,18 +25,20 @@ import (
 const allowedCharacters = "0123456789"
 
 type Table struct {
-	logger log.Logger
-	execCC allowedcmd.AllowedCommand
+	slogger *slog.Logger
+	logger  log.Logger // preserved only for temporary use in dataflattentable/etc
+	execCC  allowedcmd.AllowedCommand
 }
 
-func TablePlugin(logger log.Logger) *table.Plugin {
+func TablePlugin(slogger *slog.Logger, logger log.Logger) *table.Plugin {
 	columns := dataflattentable.Columns(
 		table.TextColumn("uid"),
 	)
 
 	t := &Table{
-		logger: logger,
-		execCC: allowedcmd.NixEnv,
+		slogger: slogger.With("table", "kolide_nix_upgradeable"),
+		logger:  logger,
+		execCC:  allowedcmd.NixEnv,
 	}
 
 	return table.NewPlugin("kolide_nix_upgradeable", columns, t.generate)
@@ -54,7 +56,11 @@ func (t *Table) generate(ctx context.Context, queryContext table.QueryContext) (
 		for _, dataQuery := range tablehelpers.GetConstraints(queryContext, "query", tablehelpers.WithDefaults("*")) {
 			output, err := t.getUserPackages(ctx, uid)
 			if err != nil {
-				level.Info(t.logger).Log("msg", "failure querying user installed packages", "err", err, "target_uid", uid)
+				t.slogger.Log(ctx, slog.LevelInfo,
+					"failure querying user installed packages",
+					"err", err,
+					"target_uid", uid,
+				)
 				continue
 			}
 
@@ -65,7 +71,10 @@ func (t *Table) generate(ctx context.Context, queryContext table.QueryContext) (
 
 			flattened, err := dataflatten.Xml(output, flattenOpts...)
 			if err != nil {
-				level.Info(t.logger).Log("msg", "failure flattening output", "err", err)
+				t.slogger.Log(ctx, slog.LevelInfo,
+					"failure flattening output",
+					"err", err,
+				)
 				continue
 			}
 
diff --git a/ee/tables/secureboot/table.go b/ee/tables/secureboot/table.go
index 9d93eaec1..bbf86abaa 100644
--- a/ee/tables/secureboot/table.go
+++ b/ee/tables/secureboot/table.go
@@ -3,25 +3,24 @@ package secureboot
 import (
 	"context"
 	"fmt"
+	"log/slog"
 
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/pkg/efi"
 	"github.com/osquery/osquery-go/plugin/table"
 )
 
 type Table struct {
-	logger log.Logger
+	slogger *slog.Logger
 }
 
-func TablePlugin(logger log.Logger) *table.Plugin {
+func TablePlugin(slogger *slog.Logger) *table.Plugin {
 	columns := []table.ColumnDefinition{
 		table.IntegerColumn("secure_boot"),
 		table.IntegerColumn("setup_mode"),
 	}
 
 	t := &Table{
-		logger: logger,
+		slogger: slogger.With("table", "kolide_secureboot"),
 	}
 
 	return table.NewPlugin("kolide_secureboot", columns, t.generate)
@@ -31,13 +30,19 @@ func (t *Table) generate(ctx context.Context, queryContext table.QueryContext) (
 
 	sb, err := efi.ReadSecureBoot()
 	if err != nil {
-		level.Info(t.logger).Log("msg", "Unable to read secureboot", "err", err)
+		t.slogger.Log(ctx, slog.LevelInfo,
+			"unable to read secureboot",
+			"err", err,
+		)
 		return nil, fmt.Errorf("Reading secure_boot from efi: %w", err)
 	}
 
 	sm, err := efi.ReadSetupMode()
 	if err != nil {
-		level.Info(t.logger).Log("msg", "Unable to read setupmode", "err", err)
+		t.slogger.Log(ctx, slog.LevelInfo,
+			"unable to read setupmode",
+			"err", err,
+		)
 		return nil, fmt.Errorf("Reading setup_mode from efi: %w", err)
 	}
 
diff --git a/ee/tables/xfconf/xfconf.go b/ee/tables/xfconf/xfconf.go
index 0f5239eb8..f7f8c1759 100644
--- a/ee/tables/xfconf/xfconf.go
+++ b/ee/tables/xfconf/xfconf.go
@@ -7,13 +7,13 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/user"
 	"path/filepath"
 	"strings"
 
 	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/dataflatten"
 	"github.com/kolide/launcher/ee/tables/dataflattentable"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
@@ -28,12 +28,14 @@ import (
 var xfconfChannelXmlPath string = filepath.Join("xfce4", "xfconf", "xfce-perchannel-xml")
 
 type xfconfTable struct {
-	logger log.Logger
+	slogger *slog.Logger
+	logger  log.Logger // preserved temporarily for use in dataflattentable and tablehelpers.Exec
 }
 
-func TablePlugin(logger log.Logger) *table.Plugin {
+func TablePlugin(slogger *slog.Logger, logger log.Logger) *table.Plugin {
 	t := &xfconfTable{
-		logger: logger,
+		slogger: slogger.With("table", "kolide_xfconf"),
+		logger:  logger,
 	}
 
 	return table.NewPlugin("kolide_xfconf", dataflattentable.Columns(table.TextColumn("username"), table.TextColumn("path")), t.generate)
@@ -57,8 +59,8 @@ func (t *xfconfTable) generate(ctx context.Context, queryContext table.QueryCont
 	for _, username := range users {
 		u, err := user.Lookup(username)
 		if err != nil {
-			level.Warn(t.logger).Log(
-				"msg", "could not find user by username",
+			t.slogger.Log(ctx, slog.LevelWarn,
+				"could not find user by username",
 				"username", username,
 				"err", err,
 			)
@@ -67,8 +69,8 @@ func (t *xfconfTable) generate(ctx context.Context, queryContext table.QueryCont
 
 		userRows, err := t.generateForUser(u, queryContext, defaultConfig)
 		if err != nil {
-			level.Warn(t.logger).Log(
-				"msg", "could not generate config for user",
+			t.slogger.Log(ctx, slog.LevelWarn,
+				"could not generate config for user",
 				"username", username,
 				"err", err,
 			)
diff --git a/ee/tables/xfconf/xfconf_test.go b/ee/tables/xfconf/xfconf_test.go
index afafc088d..88e86c032 100644
--- a/ee/tables/xfconf/xfconf_test.go
+++ b/ee/tables/xfconf/xfconf_test.go
@@ -13,6 +13,7 @@ import (
 
 	"github.com/go-kit/kit/log"
 	"github.com/kolide/kit/fsutil"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 	"github.com/osquery/osquery-go/plugin/table"
 	"github.com/stretchr/testify/require"
 )
@@ -23,7 +24,8 @@ func Test_getUserConfig(t *testing.T) {
 	tmpDefaultDir, tmpUserDir := setUpConfigFiles(t)
 
 	xfconf := xfconfTable{
-		logger: log.NewNopLogger(),
+		logger:  log.NewNopLogger(),
+		slogger: multislogger.New().Logger,
 	}
 
 	testUsername := "testUser"
diff --git a/ee/tables/xrdb/xrdb.go b/ee/tables/xrdb/xrdb.go
index a4b4818e7..cbd2600b0 100644
--- a/ee/tables/xrdb/xrdb.go
+++ b/ee/tables/xrdb/xrdb.go
@@ -10,6 +10,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
 	"os/user"
 	"strconv"
@@ -17,8 +18,6 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
 	"github.com/kolide/launcher/ee/agent"
 	"github.com/kolide/launcher/ee/allowedcmd"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
@@ -31,11 +30,11 @@ const allowedDisplayCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRST
 type execer func(ctx context.Context, display, username string, buf *bytes.Buffer) error
 
 type XRDBSettings struct {
-	logger   log.Logger
+	slogger  *slog.Logger
 	getBytes execer
 }
 
-func TablePlugin(logger log.Logger) *table.Plugin {
+func TablePlugin(slogger *slog.Logger) *table.Plugin {
 	columns := []table.ColumnDefinition{
 		table.TextColumn("key"),
 		table.TextColumn("value"),
@@ -44,7 +43,7 @@ func TablePlugin(logger log.Logger) *table.Plugin {
 	}
 
 	t := &XRDBSettings{
-		logger:   logger,
+		slogger:  slogger.With("table", "kolide_xrdb"),
 		getBytes: execXRDB,
 	}
 
@@ -69,14 +68,14 @@ func (t *XRDBSettings) generate(ctx context.Context, queryContext table.QueryCon
 
 			err := t.getBytes(ctx, display, username, &output)
 			if err != nil {
-				level.Info(t.logger).Log(
-					"msg", "error getting bytes for user",
+				t.slogger.Log(ctx, slog.LevelInfo,
+					"error getting bytes for user",
 					"username", username,
 					"err", err,
 				)
 				continue
 			}
-			user_results := t.parse(display, username, &output)
+			user_results := t.parse(ctx, display, username, &output)
 			results = append(results, user_results...)
 		}
 	}
@@ -146,7 +145,7 @@ func execXRDB(ctx context.Context, displayNum, username string, buf *bytes.Buffe
 	return nil
 }
 
-func (t *XRDBSettings) parse(display, username string, input io.Reader) []map[string]string {
+func (t *XRDBSettings) parse(ctx context.Context, display, username string, input io.Reader) []map[string]string {
 	var results []map[string]string
 
 	scanner := bufio.NewScanner(input)
@@ -159,8 +158,8 @@ func (t *XRDBSettings) parse(display, username string, input io.Reader) []map[st
 
 		parts := strings.SplitN(line, ":", 2)
 		if len(parts) < 2 {
-			level.Error(t.logger).Log(
-				"msg", "unable to process line, not enough segments",
+			t.slogger.Log(ctx, slog.LevelError,
+				"unable to process line, not enough segments",
 				"line", line,
 			)
 			continue
@@ -175,7 +174,10 @@ func (t *XRDBSettings) parse(display, username string, input io.Reader) []map[st
 	}
 
 	if err := scanner.Err(); err != nil {
-		level.Debug(t.logger).Log("msg", "scanner error", "err", err)
+		t.slogger.Log(ctx, slog.LevelDebug,
+			"scanner error",
+			"err", err,
+		)
 	}
 
 	return results
diff --git a/ee/tables/xrdb/xrdb_test.go b/ee/tables/xrdb/xrdb_test.go
index 6cdc52f5a..b8b70c40c 100644
--- a/ee/tables/xrdb/xrdb_test.go
+++ b/ee/tables/xrdb/xrdb_test.go
@@ -10,8 +10,8 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/go-kit/kit/log"
 	"github.com/kolide/launcher/ee/tables/tablehelpers"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 	"github.com/stretchr/testify/require"
 )
 
@@ -86,7 +86,7 @@ func TestXrdbParse(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		table := XRDBSettings{
-			logger: log.NewNopLogger(),
+			slogger: multislogger.New().Logger,
 			getBytes: func(ctx context.Context, display, username string, buf *bytes.Buffer) error {
 				f, err := os.Open(filepath.Join("testdata", tt.filename))
 				require.NoError(t, err, "opening file %s", tt.filename)
diff --git a/pkg/osquery/table/platform_tables_linux.go b/pkg/osquery/table/platform_tables_linux.go
index 1e92a396e..52abc88ff 100644
--- a/pkg/osquery/table/platform_tables_linux.go
+++ b/pkg/osquery/table/platform_tables_linux.go
@@ -33,16 +33,16 @@ import (
 
 func platformSpecificTables(slogger *slog.Logger, logger log.Logger, currentOsquerydBinaryPath string) []osquery.OsqueryPlugin {
 	return []osquery.OsqueryPlugin{
-		cryptsetup.TablePlugin(logger),
-		gsettings.Settings(logger),
-		gsettings.Metadata(logger),
-		nix_env_upgradeable.TablePlugin(logger),
-		secureboot.TablePlugin(logger),
-		xrdb.TablePlugin(logger),
-		fscrypt_info.TablePlugin(logger),
-		falcon_kernel_check.TablePlugin(logger),
-		falconctl.NewFalconctlOptionTable(logger),
-		xfconf.TablePlugin(logger),
+		cryptsetup.TablePlugin(slogger, logger),
+		gsettings.Settings(slogger),
+		gsettings.Metadata(slogger),
+		nix_env_upgradeable.TablePlugin(slogger, logger),
+		secureboot.TablePlugin(slogger),
+		xrdb.TablePlugin(slogger),
+		fscrypt_info.TablePlugin(slogger),
+		falcon_kernel_check.TablePlugin(slogger, logger),
+		falconctl.NewFalconctlOptionTable(slogger, logger),
+		xfconf.TablePlugin(slogger, logger),
 
 		dataflattentable.TablePluginExec(logger,
 			"kolide_nmcli_wifi", dataflattentable.KeyValueType,