feat: tf changes

Signed-off-by: Shivanshu Raj Shrivastava <shivanshu1333@gmail.com>

deploy/docker-swarm/docker-compose.ha.yaml

@@ -174,7 +174,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.83.0
+    image: signoz/signoz:v0.82.0
     command:
       - --config=/root/config/prometheus.yml
     ports:

deploy/docker-swarm/docker-compose.yaml

@@ -110,7 +110,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.83.0
+    image: signoz/signoz:v0.82.0
     command:
       - --config=/root/config/prometheus.yml
     ports:

deploy/docker/docker-compose.ha.yaml

@@ -177,7 +177,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.83.0}
+    image: signoz/signoz:${VERSION:-v0.82.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml

deploy/docker/docker-compose.yaml

@@ -110,7 +110,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.83.0}
+    image: signoz/signoz:${VERSION:-v0.82.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml

ee/query-service/app/server.go

@@ -322,6 +322,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterMessagingQueuesRoutes(r, am)
 	apiHandler.RegisterThirdPartyApiRoutes(r, am)
 	apiHandler.MetricExplorerRoutes(r, am)
+	apiHandler.RegisterTraceFunnelsRoutes(r, am)
 
 	c := cors.New(cors.Options{
 		AllowedOrigins: []string{"*"},

ee/query-service/model/plans.go

@@ -62,13 +62,6 @@ var BasicPlan = basemodel.FeatureSet{
 		UsageLimit: -1,
 		Route:      "",
 	},
-	basemodel.Feature{
-		Name:       basemodel.TraceFunnels,
-		Active:     false,
-		Usage:      0,
-		UsageLimit: -1,
-		Route:      "",
-	},
 }
 
 var EnterprisePlan = basemodel.FeatureSet{
@@ -121,11 +114,4 @@ var EnterprisePlan = basemodel.FeatureSet{
 		UsageLimit: -1,
 		Route:      "",
 	},
-	basemodel.Feature{
-		Name:       basemodel.TraceFunnels,
-		Active:     false,
-		Usage:      0,
-		UsageLimit: -1,
-		Route:      "",
-	},
 }

frontend/src/AppRoutes/index.tsx

@@ -5,7 +5,6 @@ import setLocalStorageApi from 'api/browser/localstorage/set';
 import logEvent from 'api/common/logEvent';
 import NotFound from 'components/NotFound';
 import Spinner from 'components/Spinner';
-import UserpilotRouteTracker from 'components/UserpilotRouteTracker/UserpilotRouteTracker';
 import { FeatureKeys } from 'constants/features';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import ROUTES from 'constants/routes';
@@ -355,7 +354,6 @@ function App(): JSX.Element {
 			<ConfigProvider theme={themeConfig}>
 				<Router history={history}>
 					<CompatRouter>
-						<UserpilotRouteTracker />
 						<NotificationProvider>
 							<PrivateRoute>
 								<ResourceProvider>

frontend/src/components/UserpilotRouteTracker/UserpilotRouteTracker.test.tsx

@@ -1,223 +0,0 @@
-import { render } from '@testing-library/react';
-import { act } from 'react-dom/test-utils';
-import { MemoryRouter } from 'react-router-dom';
-import { Userpilot } from 'userpilot';
-
-import UserpilotRouteTracker from './UserpilotRouteTracker';
-
-// Mock constants
-const INITIAL_PATH = '/initial';
-const TIMER_DELAY = 100;
-
-// Mock the userpilot module
-jest.mock('userpilot', () => ({
-	Userpilot: {
-		reload: jest.fn(),
-	},
-}));
-
-// Mock location state
-let mockLocation = {
-	pathname: INITIAL_PATH,
-	search: '',
-	hash: '',
-	state: null,
-};
-
-// Mock react-router-dom
-jest.mock('react-router-dom', () => {
-	const originalModule = jest.requireActual('react-router-dom');
-
-	return {
-		...originalModule,
-		useLocation: jest.fn(() => mockLocation),
-	};
-});
-
-describe('UserpilotRouteTracker', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		// Reset timers
-		jest.useFakeTimers();
-		// Reset error mock implementation
-		(Userpilot.reload as jest.Mock).mockImplementation(() => {});
-		// Reset location to initial state
-		mockLocation = {
-			pathname: INITIAL_PATH,
-			search: '',
-			hash: '',
-			state: null,
-		};
-	});
-
-	afterEach(() => {
-		jest.useRealTimers();
-	});
-
-	it('calls Userpilot.reload on initial render', () => {
-		render(
-			<MemoryRouter>
-				<UserpilotRouteTracker />
-			</MemoryRouter>,
-		);
-
-		// Fast-forward timer to trigger the setTimeout in reloadUserpilot
-		act(() => {
-			jest.advanceTimersByTime(TIMER_DELAY);
-		});
-
-		expect(Userpilot.reload).toHaveBeenCalledTimes(1);
-	});
-
-	it('calls Userpilot.reload when pathname changes', () => {
-		const { rerender } = render(
-			<MemoryRouter>
-				<UserpilotRouteTracker />
-			</MemoryRouter>,
-		);
-
-		// Fast-forward initial render timer
-		act(() => {
-			jest.advanceTimersByTime(TIMER_DELAY);
-		});
-		jest.clearAllMocks();
-
-		// Create a new location object with different pathname
-		const newLocation = {
-			...mockLocation,
-			pathname: '/new-path',
-		};
-
-		// Update the mock location with new path and trigger re-render
-		act(() => {
-			mockLocation = newLocation;
-			// Force a component update with the new location
-			rerender(
-				<MemoryRouter>
-					<UserpilotRouteTracker />
-				</MemoryRouter>,
-			);
-		});
-
-		// Fast-forward timer to allow the setTimeout to execute
-		act(() => {
-			jest.advanceTimersByTime(TIMER_DELAY);
-		});
-
-		expect(Userpilot.reload).toHaveBeenCalledTimes(1);
-	});
-
-	it('calls Userpilot.reload when search parameters change', () => {
-		const { rerender } = render(
-			<MemoryRouter>
-				<UserpilotRouteTracker />
-			</MemoryRouter>,
-		);
-
-		// Fast-forward initial render timer
-		act(() => {
-			jest.advanceTimersByTime(TIMER_DELAY);
-		});
-		jest.clearAllMocks();
-
-		// Create a new location object with different search params
-		const newLocation = {
-			...mockLocation,
-			search: '?param=value',
-		};
-
-		// Update the mock location with new search and trigger re-render
-		// eslint-disable-next-line sonarjs/no-identical-functions
-		act(() => {
-			mockLocation = newLocation;
-			// Force a component update with the new location
-			rerender(
-				<MemoryRouter>
-					<UserpilotRouteTracker />
-				</MemoryRouter>,
-			);
-		});
-
-		// Fast-forward timer to allow the setTimeout to execute
-		act(() => {
-			jest.advanceTimersByTime(TIMER_DELAY);
-		});
-
-		expect(Userpilot.reload).toHaveBeenCalledTimes(1);
-	});
-
-	it('handles errors in Userpilot.reload gracefully', () => {
-		// Mock console.error to prevent test output noise and capture calls
-		const consoleErrorSpy = jest
-			.spyOn(console, 'error')
-			.mockImplementation(() => {});
-
-		// Instead of using the component, we test the error handling behavior directly
-		const errorMsg = 'Error message';
-
-		// Set up a function that has the same error handling behavior as in component
-		const testErrorHandler = (): void => {
-			try {
-				if (typeof Userpilot !== 'undefined' && Userpilot.reload) {
-					Userpilot.reload();
-				}
-			} catch (error) {
-				console.error('[Userpilot] Error reloading on route change:', error);
-			}
-		};
-
-		// Make Userpilot.reload throw an error
-		(Userpilot.reload as jest.Mock).mockImplementation(() => {
-			throw new Error(errorMsg);
-		});
-
-		// Execute the function that should handle errors
-		testErrorHandler();
-
-		// Verify error was logged
-		expect(consoleErrorSpy).toHaveBeenCalledWith(
-			'[Userpilot] Error reloading on route change:',
-			expect.any(Error),
-		);
-
-		// Restore console mock
-		consoleErrorSpy.mockRestore();
-	});
-
-	it('does not call Userpilot.reload when same route is rendered again', () => {
-		const { rerender } = render(
-			<MemoryRouter>
-				<UserpilotRouteTracker />
-			</MemoryRouter>,
-		);
-
-		// Fast-forward initial render timer
-		act(() => {
-			jest.advanceTimersByTime(TIMER_DELAY);
-		});
-		jest.clearAllMocks();
-
-		act(() => {
-			mockLocation = {
-				pathname: mockLocation.pathname,
-				search: mockLocation.search,
-				hash: mockLocation.hash,
-				state: mockLocation.state,
-			};
-			// Force a component update with the same location
-			rerender(
-				<MemoryRouter>
-					<UserpilotRouteTracker />
-				</MemoryRouter>,
-			);
-		});
-
-		// Fast-forward timer
-		act(() => {
-			jest.advanceTimersByTime(TIMER_DELAY);
-		});
-
-		// Should not call reload since path and search are the same
-		expect(Userpilot.reload).not.toHaveBeenCalled();
-	});
-});

frontend/src/components/UserpilotRouteTracker/UserpilotRouteTracker.tsx

@@ -1,60 +0,0 @@
-import { useCallback, useEffect, useRef } from 'react';
-import { useLocation } from 'react-router-dom';
-import { Userpilot } from 'userpilot';
-
-/**
- * UserpilotRouteTracker - A component that tracks route changes and calls Userpilot.reload
- * on actual page changes (pathname changes or significant query parameter changes).
- *
- * This component renders nothing and is designed to be placed once high in the component tree.
- */
-function UserpilotRouteTracker(): null {
-	const location = useLocation();
-	const prevPathRef = useRef<string>(location.pathname);
-	const prevSearchRef = useRef<string>(location.search);
-	const isFirstRenderRef = useRef<boolean>(true);
-
-	// Function to reload Userpilot safely - using useCallback to avoid dependency issues
-	const reloadUserpilot = useCallback((): void => {
-		try {
-			if (typeof Userpilot !== 'undefined' && Userpilot.reload) {
-				setTimeout(() => {
-					Userpilot.reload();
-				}, 100);
-			}
-		} catch (error) {
-			console.error('[Userpilot] Error reloading on route change:', error);
-		}
-	}, []);
-
-	// Handle first render
-	useEffect(() => {
-		if (isFirstRenderRef.current) {
-			isFirstRenderRef.current = false;
-			reloadUserpilot();
-		}
-	}, [reloadUserpilot]);
-
-	// Handle route/query changes
-	useEffect(() => {
-		// Skip first render as it's handled by the effect above
-		if (isFirstRenderRef.current) {
-			return;
-		}
-
-		// Check if the path has changed or if significant query params have changed
-		const pathChanged = location.pathname !== prevPathRef.current;
-		const searchChanged = location.search !== prevSearchRef.current;
-
-		if (pathChanged || searchChanged) {
-			// Update refs
-			prevPathRef.current = location.pathname;
-			prevSearchRef.current = location.search;
-			reloadUserpilot();
-		}
-	}, [location.pathname, location.search, reloadUserpilot]);
-
-	return null;
-}
-
-export default UserpilotRouteTracker;

pkg/errors/errors.go

@@ -141,27 +141,3 @@ func Join(errs ...error) error {
 func As(err error, target any) bool {
 	return errors.As(err, target)
 }
-
-func WrapNotFoundf(cause error, code Code, format string, args ...interface{}) *base {
-	return Wrapf(cause, TypeNotFound, code, format, args...)
-}
-
-func NewNotFoundf(code Code, format string, args ...interface{}) *base {
-	return Newf(TypeNotFound, code, format, args...)
-}
-
-func WrapInternalf(cause error, code Code, format string, args ...interface{}) *base {
-	return Wrapf(cause, TypeInternal, code, format, args...)
-}
-
-func NewInternalf(code Code, format string, args ...interface{}) *base {
-	return Newf(TypeInternal, code, format, args...)
-}
-
-func WrapInvalidInputf(cause error, code Code, format string, args ...interface{}) *base {
-	return Wrapf(cause, TypeInvalidInput, code, format, args...)
-}
-
-func NewInvalidInputf(code Code, format string, args ...interface{}) *base {
-	return Newf(TypeInvalidInput, code, format, args...)
-}

pkg/modules/tracefunnel/impltracefunnel/handler.go

@@ -0,0 +1,294 @@
+package impltracefunnel
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
+	tf "github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/gorilla/mux"
+)
+
+type handler struct {
+	module tracefunnel.Module
+}
+
+func NewHandler(module tracefunnel.Module) tracefunnel.Handler {
+	return &handler{module: module}
+}
+
+func (handler *handler) New(rw http.ResponseWriter, r *http.Request) {
+	var req tf.FunnelRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	claims, err := tracefunnel.GetClaims(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	funnel, err := handler.module.Create(r.Context(), req.Timestamp, req.Name, claims.UserID, claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to create funnel: %v", err))
+		return
+	}
+
+	response := tracefunnel.ConstructFunnelResponse(funnel, claims)
+	render.Success(rw, http.StatusOK, response)
+}
+
+func (handler *handler) UpdateSteps(rw http.ResponseWriter, r *http.Request) {
+	var req tf.FunnelRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	claims, err := tracefunnel.GetClaims(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	updatedAt, err := tracefunnel.ValidateAndConvertTimestamp(req.Timestamp)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	funnel, err := handler.module.Get(r.Context(), req.FunnelID.String())
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"funnel not found: %v", err))
+		return
+	}
+
+	steps, err := tracefunnel.ProcessFunnelSteps(req.Steps)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	funnel.Steps = steps
+	funnel.UpdatedAt = updatedAt
+	funnel.UpdatedBy = claims.UserID
+
+	if req.Name != "" {
+		funnel.Name = req.Name
+	}
+	if req.Description != "" {
+		funnel.Description = req.Description
+	}
+
+	if err := handler.module.Update(r.Context(), funnel, claims.UserID); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to update funnel in database: %v", err))
+		return
+	}
+
+	updatedFunnel, err := handler.module.Get(r.Context(), funnel.ID.String())
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to get updated funnel: %v", err))
+		return
+	}
+
+	response := tracefunnel.ConstructFunnelResponse(updatedFunnel, claims)
+	render.Success(rw, http.StatusOK, response)
+}
+
+func (handler *handler) UpdateFunnel(rw http.ResponseWriter, r *http.Request) {
+	var req tf.FunnelRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	claims, err := tracefunnel.GetClaims(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	updatedAt, err := tracefunnel.ValidateAndConvertTimestamp(req.Timestamp)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := handler.module.Get(r.Context(), funnelID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"funnel not found: %v", err))
+		return
+	}
+
+	funnel.UpdatedAt = updatedAt
+	funnel.UpdatedBy = claims.UserID
+
+	if req.Name != "" {
+		funnel.Name = req.Name
+	}
+	if req.Description != "" {
+		funnel.Description = req.Description
+	}
+
+	if err := handler.module.Update(r.Context(), funnel, claims.UserID); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to update funnel in database: %v", err))
+		return
+	}
+
+	updatedFunnel, err := handler.module.Get(r.Context(), funnel.ID.String())
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to get updated funnel: %v", err))
+		return
+	}
+
+	response := tracefunnel.ConstructFunnelResponse(updatedFunnel, claims)
+	render.Success(rw, http.StatusOK, response)
+}
+
+func (handler *handler) List(rw http.ResponseWriter, r *http.Request) {
+	claims, err := tracefunnel.GetClaims(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	funnels, err := handler.module.List(r.Context(), claims.OrgID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to list funnels: %v", err))
+		return
+	}
+
+	var response []tf.FunnelResponse
+	for _, f := range funnels {
+		response = append(response, tracefunnel.ConstructFunnelResponse(f, claims))
+	}
+
+	render.Success(rw, http.StatusOK, response)
+}
+
+func (handler *handler) Get(rw http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := handler.module.Get(r.Context(), funnelID)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"funnel not found: %v", err))
+		return
+	}
+
+	claims, _ := tracefunnel.GetClaims(r) // Ignore error as email is optional
+	response := tracefunnel.ConstructFunnelResponse(funnel, claims)
+	render.Success(rw, http.StatusOK, response)
+}
+
+func (handler *handler) Delete(rw http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	if err := handler.module.Delete(r.Context(), funnelID); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to delete funnel: %v", err))
+		return
+	}
+
+	render.Success(rw, http.StatusOK, nil)
+}
+
+func (handler *handler) Save(rw http.ResponseWriter, r *http.Request) {
+	var req tf.FunnelRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"invalid request: %v", err))
+		return
+	}
+
+	claims, err := tracefunnel.GetClaims(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	funnel, err := handler.module.Get(r.Context(), req.FunnelID.String())
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"funnel not found: %v", err))
+		return
+	}
+
+	updateTimestamp := req.Timestamp
+	if updateTimestamp == 0 {
+		updateTimestamp = time.Now().UnixMilli()
+	} else if !tracefunnel.ValidateTimestampIsMilliseconds(updateTimestamp) {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"timestamp must be in milliseconds format (13 digits)"))
+		return
+	}
+
+	updatedAt, err := tracefunnel.ValidateAndConvertTimestamp(updateTimestamp)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	funnel.UpdatedAt = updatedAt
+	funnel.UpdatedBy = claims.UserID
+	funnel.Description = req.Description
+
+	if err := handler.module.Save(r.Context(), funnel, funnel.UpdatedBy, claims.OrgID); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to save funnel: %v", err))
+		return
+	}
+
+	createdAtMillis, updatedAtMillis, extraDataFromDB, err := handler.module.GetFunnelMetadata(r.Context(), funnel.ID.String())
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"failed to get funnel metadata: %v", err))
+		return
+	}
+
+	resp := tf.FunnelResponse{
+		FunnelName:  funnel.Name,
+		CreatedAt:   createdAtMillis,
+		UpdatedAt:   updatedAtMillis,
+		CreatedBy:   funnel.CreatedBy,
+		UpdatedBy:   funnel.UpdatedBy,
+		OrgID:       funnel.OrgID.String(),
+		Description: extraDataFromDB,
+		UserEmail:   claims.Email,
+	}
+
+	render.Success(rw, http.StatusOK, resp)
+}

pkg/modules/tracefunnel/impltracefunnel/handler_test.go

@@ -0,0 +1,421 @@
+package impltracefunnel
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/gorilla/mux"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type MockModule struct {
+	mock.Mock
+}
+
+func (m *MockModule) Create(ctx context.Context, timestamp int64, name string, userID string, orgID string) (*traceFunnels.Funnel, error) {
+	args := m.Called(ctx, timestamp, name, userID, orgID)
+	return args.Get(0).(*traceFunnels.Funnel), args.Error(1)
+}
+
+func (m *MockModule) Get(ctx context.Context, funnelID string) (*traceFunnels.Funnel, error) {
+	args := m.Called(ctx, funnelID)
+	return args.Get(0).(*traceFunnels.Funnel), args.Error(1)
+}
+
+func (m *MockModule) Update(ctx context.Context, funnel *traceFunnels.Funnel, userID string) error {
+	args := m.Called(ctx, funnel, userID)
+	return args.Error(0)
+}
+
+func (m *MockModule) List(ctx context.Context, orgID string) ([]*traceFunnels.Funnel, error) {
+	args := m.Called(ctx, orgID)
+	return args.Get(0).([]*traceFunnels.Funnel), args.Error(1)
+}
+
+func (m *MockModule) Delete(ctx context.Context, funnelID string) error {
+	args := m.Called(ctx, funnelID)
+	return args.Error(0)
+}
+
+func (m *MockModule) Save(ctx context.Context, funnel *traceFunnels.Funnel, userID string, orgID string) error {
+	args := m.Called(ctx, funnel, userID, orgID)
+	return args.Error(0)
+}
+
+func (m *MockModule) GetFunnelMetadata(ctx context.Context, funnelID string) (int64, int64, string, error) {
+	args := m.Called(ctx, funnelID)
+	return args.Get(0).(int64), args.Get(1).(int64), args.String(2), args.Error(3)
+}
+
+func TestHandler_New(t *testing.T) {
+	mockModule := new(MockModule)
+	handler := NewHandler(mockModule)
+
+	reqBody := traceFunnels.FunnelRequest{
+		Name:      "test-funnel",
+		Timestamp: time.Now().UnixMilli(),
+	}
+
+	jsonBody, _ := json.Marshal(reqBody)
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/trace-funnels/new", bytes.NewBuffer(jsonBody))
+	req.Header.Set("Content-Type", "application/json")
+
+	orgID := valuer.GenerateUUID().String()
+	claims := authtypes.Claims{
+		UserID: "user-123",
+		OrgID:  orgID,
+		Email:  "test@example.com",
+	}
+	req = req.WithContext(authtypes.NewContextWithClaims(req.Context(), claims))
+
+	rr := httptest.NewRecorder()
+
+	funnelID := valuer.GenerateUUID()
+	expectedFunnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Identifiable: types.Identifiable{
+				ID: funnelID,
+			},
+			Name:  reqBody.Name,
+			OrgID: valuer.MustNewUUID(orgID),
+		},
+	}
+
+	mockModule.On("List", req.Context(), orgID).Return([]*traceFunnels.Funnel{}, nil)
+	mockModule.On("Create", req.Context(), reqBody.Timestamp, reqBody.Name, "user-123", orgID).Return(expectedFunnel, nil)
+
+	handler.New(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response struct {
+		Status string                      `json:"status"`
+		Data   traceFunnels.FunnelResponse `json:"data"`
+	}
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err)
+	assert.Equal(t, "success", response.Status)
+	assert.Equal(t, reqBody.Name, response.Data.FunnelName)
+	assert.Equal(t, orgID, response.Data.OrgID)
+	assert.Equal(t, "test@example.com", response.Data.UserEmail)
+
+	mockModule.AssertExpectations(t)
+}
+
+func TestHandler_Update(t *testing.T) {
+	mockModule := new(MockModule)
+	handler := NewHandler(mockModule)
+
+	// Create a valid UUID for the funnel ID
+	funnelID := valuer.GenerateUUID()
+	orgID := valuer.GenerateUUID().String()
+
+	reqBody := traceFunnels.FunnelRequest{
+		FunnelID: funnelID,
+		Name:     "updated-funnel",
+		Steps: []traceFunnels.FunnelStep{
+			{
+				ID:          valuer.GenerateUUID(),
+				Name:        "Step 1",
+				ServiceName: "test-service",
+				SpanName:    "test-span",
+				Order:       1,
+			},
+			{
+				ID:          valuer.GenerateUUID(),
+				Name:        "Step 2",
+				ServiceName: "test-service",
+				SpanName:    "test-span-2",
+				Order:       2,
+			},
+		},
+		Timestamp: time.Now().UnixMilli(),
+	}
+
+	body, err := json.Marshal(reqBody)
+	assert.NoError(t, err)
+
+	req, err := http.NewRequest(http.MethodPut, "/api/v1/trace-funnels/steps/update", bytes.NewBuffer(body))
+	assert.NoError(t, err)
+	req.Header.Set("Content-Type", "application/json")
+
+	// Set up context with claims
+	claims := authtypes.Claims{
+		UserID: "user-123",
+		OrgID:  orgID,
+		Email:  "test@example.com",
+	}
+	ctx := authtypes.NewContextWithClaims(req.Context(), claims)
+	req = req.WithContext(ctx)
+
+	rr := httptest.NewRecorder()
+
+	// Set up mock expectations
+	existingFunnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Identifiable: types.Identifiable{
+				ID: funnelID,
+			},
+			Name:  "test-funnel",
+			OrgID: valuer.MustNewUUID(orgID),
+			TimeAuditable: types.TimeAuditable{
+				CreatedAt: time.Now(),
+				UpdatedAt: time.Now(),
+			},
+			UserAuditable: types.UserAuditable{
+				CreatedBy: "user-123",
+				UpdatedBy: "user-123",
+			},
+		},
+		CreatedByUser: &types.User{
+			ID:    "user-123",
+			Email: "test@example.com",
+		},
+	}
+
+	updatedFunnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Identifiable: types.Identifiable{
+				ID: funnelID,
+			},
+			Name:  reqBody.Name,
+			OrgID: valuer.MustNewUUID(orgID),
+			TimeAuditable: types.TimeAuditable{
+				CreatedAt: time.Now(),
+				UpdatedAt: time.Unix(0, reqBody.Timestamp*1000000),
+			},
+			UserAuditable: types.UserAuditable{
+				CreatedBy: "user-123",
+				UpdatedBy: "user-123",
+			},
+		},
+		Steps: reqBody.Steps,
+		CreatedByUser: &types.User{
+			ID:    "user-123",
+			Email: "test@example.com",
+		},
+	}
+
+	// First Get call to validate the funnel exists
+	mockModule.On("Get", req.Context(), funnelID.String()).Return(existingFunnel, nil).Once()
+	// List call to check for name conflicts
+	mockModule.On("List", req.Context(), orgID).Return([]*traceFunnels.Funnel{}, nil).Once()
+	// Update call to save the changes
+	mockModule.On("Update", req.Context(), mock.MatchedBy(func(f *traceFunnels.Funnel) bool {
+		return f.Name == reqBody.Name &&
+			f.ID.String() == funnelID.String() &&
+			len(f.Steps) == len(reqBody.Steps) &&
+			f.Steps[0].Name == reqBody.Steps[0].Name &&
+			f.Steps[0].ServiceName == reqBody.Steps[0].ServiceName &&
+			f.Steps[0].SpanName == reqBody.Steps[0].SpanName &&
+			f.Steps[1].Name == reqBody.Steps[1].Name &&
+			f.Steps[1].ServiceName == reqBody.Steps[1].ServiceName &&
+			f.Steps[1].SpanName == reqBody.Steps[1].SpanName &&
+			f.UpdatedAt.UnixNano()/1000000 == reqBody.Timestamp &&
+			f.UpdatedBy == "user-123"
+	}), "user-123").Return(nil).Once()
+	// Second Get call to get the updated funnel for the response
+	mockModule.On("Get", req.Context(), funnelID.String()).Return(updatedFunnel, nil).Once()
+
+	handler.UpdateSteps(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response struct {
+		Status string                      `json:"status"`
+		Data   traceFunnels.FunnelResponse `json:"data"`
+	}
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err)
+	assert.Equal(t, "success", response.Status)
+	assert.Equal(t, "updated-funnel", response.Data.FunnelName)
+	assert.Equal(t, funnelID.String(), response.Data.FunnelID)
+	assert.Equal(t, "test@example.com", response.Data.UserEmail)
+
+	mockModule.AssertExpectations(t)
+}
+
+func TestHandler_List(t *testing.T) {
+	mockModule := new(MockModule)
+	handler := NewHandler(mockModule)
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/trace-funnels/list", nil)
+
+	orgID := valuer.GenerateUUID().String()
+	claims := authtypes.Claims{
+		OrgID: orgID,
+	}
+	req = req.WithContext(authtypes.NewContextWithClaims(req.Context(), claims))
+
+	rr := httptest.NewRecorder()
+
+	funnel1ID := valuer.GenerateUUID()
+	funnel2ID := valuer.GenerateUUID()
+	expectedFunnels := []*traceFunnels.Funnel{
+		{
+			BaseMetadata: traceFunnels.BaseMetadata{
+				Identifiable: types.Identifiable{
+					ID: funnel1ID,
+				},
+				Name:  "funnel-1",
+				OrgID: valuer.MustNewUUID(orgID),
+			},
+		},
+		{
+			BaseMetadata: traceFunnels.BaseMetadata{
+				Identifiable: types.Identifiable{
+					ID: funnel2ID,
+				},
+				Name:  "funnel-2",
+				OrgID: valuer.MustNewUUID(orgID),
+			},
+		},
+	}
+
+	mockModule.On("List", req.Context(), orgID).Return(expectedFunnels, nil)
+
+	handler.List(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response struct {
+		Status string                        `json:"status"`
+		Data   []traceFunnels.FunnelResponse `json:"data"`
+	}
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err)
+	assert.Equal(t, "success", response.Status)
+	assert.Len(t, response.Data, 2)
+	assert.Equal(t, "funnel-1", response.Data[0].FunnelName)
+	assert.Equal(t, "funnel-2", response.Data[1].FunnelName)
+
+	mockModule.AssertExpectations(t)
+}
+
+func TestHandler_Get(t *testing.T) {
+	mockModule := new(MockModule)
+	handler := NewHandler(mockModule)
+
+	funnelID := valuer.GenerateUUID()
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/trace-funnels/"+funnelID.String(), nil)
+	req = mux.SetURLVars(req, map[string]string{"funnel_id": funnelID.String()})
+
+	rr := httptest.NewRecorder()
+
+	expectedFunnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Identifiable: types.Identifiable{
+				ID: funnelID,
+			},
+			Name:  "test-funnel",
+			OrgID: valuer.GenerateUUID(),
+		},
+	}
+
+	mockModule.On("Get", req.Context(), funnelID.String()).Return(expectedFunnel, nil)
+
+	handler.Get(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response struct {
+		Status string                      `json:"status"`
+		Data   traceFunnels.FunnelResponse `json:"data"`
+	}
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err)
+	assert.Equal(t, "success", response.Status)
+	assert.Equal(t, "test-funnel", response.Data.FunnelName)
+	assert.Equal(t, expectedFunnel.OrgID.String(), response.Data.OrgID)
+
+	mockModule.AssertExpectations(t)
+}
+
+func TestHandler_Delete(t *testing.T) {
+	mockModule := new(MockModule)
+	handler := NewHandler(mockModule)
+
+	funnelID := valuer.GenerateUUID()
+	req := httptest.NewRequest(http.MethodDelete, "/api/v1/trace-funnels/"+funnelID.String(), nil)
+	req = mux.SetURLVars(req, map[string]string{"funnel_id": funnelID.String()})
+
+	rr := httptest.NewRecorder()
+
+	mockModule.On("Delete", req.Context(), funnelID.String()).Return(nil)
+
+	handler.Delete(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	mockModule.AssertExpectations(t)
+}
+
+func TestHandler_Save(t *testing.T) {
+	mockModule := new(MockModule)
+	handler := NewHandler(mockModule)
+
+	reqBody := traceFunnels.FunnelRequest{
+		FunnelID:    valuer.GenerateUUID(),
+		Description: "updated description",
+		Timestamp:   time.Now().UnixMilli(),
+		UserID:      "user-123",
+	}
+
+	jsonBody, _ := json.Marshal(reqBody)
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/trace-funnels/save", bytes.NewBuffer(jsonBody))
+	req.Header.Set("Content-Type", "application/json")
+
+	orgID := valuer.GenerateUUID().String()
+	claims := authtypes.Claims{
+		UserID: "user-123",
+		OrgID:  orgID,
+	}
+	req = req.WithContext(authtypes.NewContextWithClaims(req.Context(), claims))
+
+	rr := httptest.NewRecorder()
+
+	existingFunnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Identifiable: types.Identifiable{
+				ID: reqBody.FunnelID,
+			},
+			Name:  "test-funnel",
+			OrgID: valuer.MustNewUUID(orgID),
+		},
+	}
+
+	mockModule.On("Get", req.Context(), reqBody.FunnelID.String()).Return(existingFunnel, nil)
+	mockModule.On("Save", req.Context(), mock.MatchedBy(func(f *traceFunnels.Funnel) bool {
+		return f.ID.String() == reqBody.FunnelID.String() &&
+			f.Name == existingFunnel.Name &&
+			f.Description == reqBody.Description &&
+			f.UpdatedBy == "user-123" &&
+			f.OrgID.String() == orgID
+	}), "user-123", orgID).Return(nil)
+	mockModule.On("GetFunnelMetadata", req.Context(), reqBody.FunnelID.String()).Return(int64(0), int64(0), reqBody.Description, nil)
+
+	handler.Save(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response struct {
+		Status string                      `json:"status"`
+		Data   traceFunnels.FunnelResponse `json:"data"`
+	}
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err)
+	assert.Equal(t, "success", response.Status)
+	assert.Equal(t, reqBody.Description, response.Data.Description)
+
+	mockModule.AssertExpectations(t)
+}

pkg/modules/tracefunnel/impltracefunnel/module.go

@@ -0,0 +1,115 @@
+package impltracefunnel
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/types"
+	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type module struct {
+	store traceFunnels.FunnelStore
+}
+
+func NewModule(store traceFunnels.FunnelStore) tracefunnel.Module {
+	return &module{
+		store: store,
+	}
+}
+
+func (module *module) Create(ctx context.Context, timestamp int64, name string, userID string, orgID string) (*traceFunnels.Funnel, error) {
+	orgUUID, err := valuer.NewUUID(orgID)
+	if err != nil {
+		return nil, fmt.Errorf("invalid org ID: %v", err)
+	}
+
+	funnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Name:  name,
+			OrgID: orgUUID,
+		},
+	}
+	funnel.CreatedAt = time.Unix(0, timestamp*1000000) // Convert to nanoseconds
+	funnel.CreatedBy = userID
+
+	// Set up the user relationship
+	funnel.CreatedByUser = &types.User{
+		ID: userID,
+	}
+
+	if err := module.store.Create(ctx, funnel); err != nil {
+		return nil, fmt.Errorf("failed to create funnel: %v", err)
+	}
+
+	return funnel, nil
+}
+
+// Get gets a funnel by ID
+func (module *module) Get(ctx context.Context, funnelID string) (*traceFunnels.Funnel, error) {
+	uuid, err := valuer.NewUUID(funnelID)
+	if err != nil {
+		return nil, fmt.Errorf("invalid funnel ID: %v", err)
+	}
+	return module.store.Get(ctx, uuid)
+}
+
+// Update updates a funnel
+func (module *module) Update(ctx context.Context, funnel *traceFunnels.Funnel, userID string) error {
+	funnel.UpdatedBy = userID
+	return module.store.Update(ctx, funnel)
+}
+
+// List lists all funnels for an organization
+func (module *module) List(ctx context.Context, orgID string) ([]*traceFunnels.Funnel, error) {
+	orgUUID, err := valuer.NewUUID(orgID)
+	if err != nil {
+		return nil, fmt.Errorf("invalid org ID: %v", err)
+	}
+
+	funnels, err := module.store.List(ctx, orgUUID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list funnels: %v", err)
+	}
+
+	return funnels, nil
+}
+
+// Delete deletes a funnel
+func (module *module) Delete(ctx context.Context, funnelID string) error {
+	uuid, err := valuer.NewUUID(funnelID)
+	if err != nil {
+		return fmt.Errorf("invalid funnel ID: %v", err)
+	}
+	return module.store.Delete(ctx, uuid)
+}
+
+// Save saves a funnel
+func (module *module) Save(ctx context.Context, funnel *traceFunnels.Funnel, userID string, orgID string) error {
+	orgUUID, err := valuer.NewUUID(orgID)
+	if err != nil {
+		return fmt.Errorf("invalid org ID: %v", err)
+	}
+
+	funnel.UpdatedBy = userID
+	funnel.OrgID = orgUUID
+	return module.store.Update(ctx, funnel)
+}
+
+// GetFunnelMetadata gets metadata for a funnel
+func (module *module) GetFunnelMetadata(ctx context.Context, funnelID string) (int64, int64, string, error) {
+	uuid, err := valuer.NewUUID(funnelID)
+	if err != nil {
+		return 0, 0, "", fmt.Errorf("invalid funnel ID: %v", err)
+	}
+
+	funnel, err := module.store.Get(ctx, uuid)
+	if err != nil {
+		return 0, 0, "", err
+	}
+
+	return funnel.CreatedAt.UnixNano() / 1000000, funnel.UpdatedAt.UnixNano() / 1000000, funnel.Description, nil
+}

pkg/modules/tracefunnel/impltracefunnel/module_test.go

@@ -0,0 +1,213 @@
+package impltracefunnel
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types"
+	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type MockStore struct {
+	mock.Mock
+}
+
+func (m *MockStore) Create(ctx context.Context, funnel *traceFunnels.Funnel) error {
+	args := m.Called(ctx, funnel)
+	return args.Error(0)
+}
+
+func (m *MockStore) Get(ctx context.Context, uuid valuer.UUID) (*traceFunnels.Funnel, error) {
+	args := m.Called(ctx, uuid)
+	return args.Get(0).(*traceFunnels.Funnel), args.Error(1)
+}
+
+func (m *MockStore) List(ctx context.Context, orgID valuer.UUID) ([]*traceFunnels.Funnel, error) {
+	args := m.Called(ctx, orgID)
+	return args.Get(0).([]*traceFunnels.Funnel), args.Error(1)
+}
+
+func (m *MockStore) Update(ctx context.Context, funnel *traceFunnels.Funnel) error {
+	args := m.Called(ctx, funnel)
+	return args.Error(0)
+}
+
+func (m *MockStore) Delete(ctx context.Context, uuid valuer.UUID) error {
+	args := m.Called(ctx, uuid)
+	return args.Error(0)
+}
+
+func TestModule_Create(t *testing.T) {
+	mockStore := new(MockStore)
+	module := NewModule(mockStore)
+
+	ctx := context.Background()
+	timestamp := time.Now().UnixMilli()
+	name := "test-funnel"
+	userID := "user-123"
+	orgID := valuer.GenerateUUID().String()
+
+	mockStore.On("Create", ctx, mock.MatchedBy(func(f *traceFunnels.Funnel) bool {
+		return f.Name == name &&
+			f.CreatedBy == userID &&
+			f.OrgID.String() == orgID &&
+			f.CreatedByUser != nil &&
+			f.CreatedByUser.ID == userID &&
+			f.CreatedAt.UnixNano()/1000000 == timestamp
+	})).Return(nil)
+
+	funnel, err := module.Create(ctx, timestamp, name, userID, orgID)
+	assert.NoError(t, err)
+	assert.NotNil(t, funnel)
+	assert.Equal(t, name, funnel.Name)
+	assert.Equal(t, userID, funnel.CreatedBy)
+	assert.Equal(t, orgID, funnel.OrgID.String())
+	assert.NotNil(t, funnel.CreatedByUser)
+	assert.Equal(t, userID, funnel.CreatedByUser.ID)
+
+	mockStore.AssertExpectations(t)
+}
+
+func TestModule_Get(t *testing.T) {
+	mockStore := new(MockStore)
+	module := NewModule(mockStore)
+
+	ctx := context.Background()
+	funnelID := valuer.GenerateUUID().String()
+	expectedFunnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Name: "test-funnel",
+		},
+	}
+
+	mockStore.On("Get", ctx, mock.AnythingOfType("valuer.UUID")).Return(expectedFunnel, nil)
+
+	funnel, err := module.Get(ctx, funnelID)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedFunnel, funnel)
+
+	mockStore.AssertExpectations(t)
+}
+
+func TestModule_Update(t *testing.T) {
+	mockStore := new(MockStore)
+	module := NewModule(mockStore)
+
+	ctx := context.Background()
+	userID := "user-123"
+	funnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Name: "test-funnel",
+		},
+	}
+
+	mockStore.On("Update", ctx, funnel).Return(nil)
+
+	err := module.Update(ctx, funnel, userID)
+	assert.NoError(t, err)
+	assert.Equal(t, userID, funnel.UpdatedBy)
+
+	mockStore.AssertExpectations(t)
+}
+
+func TestModule_List(t *testing.T) {
+	mockStore := new(MockStore)
+	module := NewModule(mockStore)
+
+	ctx := context.Background()
+	orgID := valuer.GenerateUUID().String()
+	orgUUID := valuer.MustNewUUID(orgID)
+	expectedFunnels := []*traceFunnels.Funnel{
+		{
+			BaseMetadata: traceFunnels.BaseMetadata{
+				Name:  "funnel-1",
+				OrgID: orgUUID,
+			},
+		},
+		{
+			BaseMetadata: traceFunnels.BaseMetadata{
+				Name:  "funnel-2",
+				OrgID: orgUUID,
+			},
+		},
+	}
+
+	mockStore.On("List", ctx, orgUUID).Return(expectedFunnels, nil)
+
+	funnels, err := module.List(ctx, orgID)
+	assert.NoError(t, err)
+	assert.Len(t, funnels, 2)
+	assert.Equal(t, expectedFunnels, funnels)
+
+	mockStore.AssertExpectations(t)
+}
+
+func TestModule_Delete(t *testing.T) {
+	mockStore := new(MockStore)
+	module := NewModule(mockStore)
+
+	ctx := context.Background()
+	funnelID := valuer.GenerateUUID().String()
+
+	mockStore.On("Delete", ctx, mock.AnythingOfType("valuer.UUID")).Return(nil)
+
+	err := module.Delete(ctx, funnelID)
+	assert.NoError(t, err)
+
+	mockStore.AssertExpectations(t)
+}
+
+func TestModule_Save(t *testing.T) {
+	mockStore := new(MockStore)
+	module := NewModule(mockStore)
+
+	ctx := context.Background()
+	userID := "user-123"
+	orgID := valuer.GenerateUUID().String()
+	funnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Name: "test-funnel",
+		},
+	}
+
+	mockStore.On("Update", ctx, funnel).Return(nil)
+
+	err := module.Save(ctx, funnel, userID, orgID)
+	assert.NoError(t, err)
+	assert.Equal(t, userID, funnel.UpdatedBy)
+	assert.Equal(t, orgID, funnel.OrgID.String())
+
+	mockStore.AssertExpectations(t)
+}
+
+func TestModule_GetFunnelMetadata(t *testing.T) {
+	mockStore := new(MockStore)
+	module := NewModule(mockStore)
+
+	ctx := context.Background()
+	funnelID := valuer.GenerateUUID().String()
+	now := time.Now()
+	expectedFunnel := &traceFunnels.Funnel{
+		BaseMetadata: traceFunnels.BaseMetadata{
+			Description: "test description",
+			TimeAuditable: types.TimeAuditable{
+				CreatedAt: now,
+				UpdatedAt: now,
+			},
+		},
+	}
+
+	mockStore.On("Get", ctx, mock.AnythingOfType("valuer.UUID")).Return(expectedFunnel, nil)
+
+	createdAt, updatedAt, description, err := module.GetFunnelMetadata(ctx, funnelID)
+	assert.NoError(t, err)
+	assert.Equal(t, now.UnixNano()/1000000, createdAt)
+	assert.Equal(t, now.UnixNano()/1000000, updatedAt)
+	assert.Equal(t, "test description", description)
+
+	mockStore.AssertExpectations(t)
+}

pkg/modules/tracefunnel/impltracefunnel/store.go

@@ -0,0 +1,114 @@
+package impltracefunnel
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type store struct {
+	sqlstore sqlstore.SQLStore
+}
+
+func NewStore(sqlstore sqlstore.SQLStore) traceFunnels.FunnelStore {
+	return &store{sqlstore: sqlstore}
+}
+
+func (store *store) Create(ctx context.Context, funnel *traceFunnels.Funnel) error {
+	if funnel.ID.IsZero() {
+		funnel.ID = valuer.GenerateUUID()
+	}
+
+	if funnel.CreatedAt.IsZero() {
+		funnel.CreatedAt = time.Now()
+	}
+	if funnel.UpdatedAt.IsZero() {
+		funnel.UpdatedAt = time.Now()
+	}
+
+	// Set created_by if CreatedByUser is present
+	if funnel.CreatedByUser != nil {
+		funnel.CreatedBy = funnel.CreatedByUser.ID
+	}
+
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewInsert().
+		Model(funnel).
+		Exec(ctx)
+	if err != nil {
+		return store.sqlstore.WrapAlreadyExistsErrf(err, traceFunnels.ErrFunnelAlreadyExists, "a funnel with name '%s' already exists in this organization", funnel.Name)
+	}
+
+	return nil
+}
+
+// Get retrieves a funnel by ID
+func (store *store) Get(ctx context.Context, uuid valuer.UUID) (*traceFunnels.Funnel, error) {
+	funnel := &traceFunnels.Funnel{}
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(funnel).
+		Relation("CreatedByUser").
+		Where("?TableAlias.id = ?", uuid).
+		Scan(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get funnel: %v", err)
+	}
+	return funnel, nil
+}
+
+// Update updates an existing funnel
+func (store *store) Update(ctx context.Context, funnel *traceFunnels.Funnel) error {
+	funnel.UpdatedAt = time.Now()
+
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewUpdate().
+		Model(funnel).
+		WherePK().
+		Exec(ctx)
+	if err != nil {
+		return store.sqlstore.WrapAlreadyExistsErrf(err, traceFunnels.ErrFunnelAlreadyExists, "a funnel with name '%s' already exists in this organization", funnel.Name)
+	}
+	return nil
+}
+
+// List retrieves all funnels for a given organization
+func (store *store) List(ctx context.Context, orgID valuer.UUID) ([]*traceFunnels.Funnel, error) {
+	var funnels []*traceFunnels.Funnel
+	err := store.
+		sqlstore.
+		BunDB().
+		NewSelect().
+		Model(&funnels).
+		Relation("CreatedByUser").
+		Where("?TableAlias.org_id = ?", orgID).
+		Scan(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list funnels: %v", err)
+	}
+	return funnels, nil
+}
+
+// Delete removes a funnel by ID
+func (store *store) Delete(ctx context.Context, uuid valuer.UUID) error {
+	_, err := store.
+		sqlstore.
+		BunDB().
+		NewDelete().
+		Model((*traceFunnels.Funnel)(nil)).
+		Where("id = ?", uuid).Exec(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to delete funnel: %v", err)
+	}
+	return nil
+}

pkg/modules/tracefunnel/query.go

@@ -0,0 +1,420 @@
+package tracefunnel
+
+import (
+	"fmt"
+	tracev4 "github.com/SigNoz/signoz/pkg/query-service/app/traces/v4"
+	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"strings"
+)
+
+func ValidateTraces(funnel *tracefunnel.Funnel, timeRange tracefunnel.TimeRange) (*v3.ClickHouseQuery, error) {
+	var query string
+	var err error
+
+	funnelSteps := funnel.Steps
+	containsErrorT1 := 0
+	containsErrorT2 := 0
+	containsErrorT3 := 0
+
+	if funnelSteps[0].HasErrors {
+		containsErrorT1 = 1
+	}
+	if funnelSteps[1].HasErrors {
+		containsErrorT2 = 1
+	}
+	if len(funnel.Steps) > 2 && funnelSteps[2].HasErrors {
+		containsErrorT3 = 1
+	}
+
+	// Build filter clauses for each step
+	clauseStep1, err := tracev4.BuildTracesFilterQuery(funnelSteps[0].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep2, err := tracev4.BuildTracesFilterQuery(funnelSteps[1].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep3 := ""
+	if len(funnel.Steps) > 2 {
+		clauseStep3, err = tracev4.BuildTracesFilterQuery(funnelSteps[2].Filters)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if len(funnel.Steps) > 2 {
+		query = BuildThreeStepFunnelValidationQuery(
+			containsErrorT1,            // containsErrorT1
+			containsErrorT2,            // containsErrorT2
+			containsErrorT3,            // containsErrorT3
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			funnelSteps[2].ServiceName, // serviceNameT1
+			funnelSteps[2].SpanName,    // spanNameT3
+			clauseStep1,
+			clauseStep2,
+			clauseStep3,
+		)
+	} else {
+		query = BuildTwoStepFunnelValidationQuery(
+			containsErrorT1,            // containsErrorT1
+			containsErrorT2,            // containsErrorT2
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			clauseStep1,
+			clauseStep2,
+		)
+	}
+
+	return &v3.ClickHouseQuery{
+		Query: query,
+	}, nil
+}
+
+func GetFunnelAnalytics(funnel *tracefunnel.Funnel, timeRange tracefunnel.TimeRange) (*v3.ClickHouseQuery, error) {
+	var query string
+	var err error
+
+	funnelSteps := funnel.Steps
+	containsErrorT1 := 0
+	containsErrorT2 := 0
+	containsErrorT3 := 0
+	latencyPointerT1 := funnelSteps[0].LatencyPointer
+	latencyPointerT2 := funnelSteps[1].LatencyPointer
+	latencyPointerT3 := "start"
+	if len(funnel.Steps) > 2 {
+		latencyPointerT3 = funnelSteps[2].LatencyPointer
+	}
+
+	if funnelSteps[0].HasErrors {
+		containsErrorT1 = 1
+	}
+	if funnelSteps[1].HasErrors {
+		containsErrorT2 = 1
+	}
+	if len(funnel.Steps) > 2 && funnelSteps[2].HasErrors {
+		containsErrorT3 = 1
+	}
+
+	// Build filter clauses for each step
+	clauseStep1, err := tracev4.BuildTracesFilterQuery(funnelSteps[0].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep2, err := tracev4.BuildTracesFilterQuery(funnelSteps[1].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep3 := ""
+	if len(funnel.Steps) > 2 {
+		clauseStep3, err = tracev4.BuildTracesFilterQuery(funnelSteps[2].Filters)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if len(funnel.Steps) > 2 {
+		query = BuildThreeStepFunnelOverviewQuery(
+			containsErrorT1, // containsErrorT1
+			containsErrorT2, // containsErrorT2
+			containsErrorT3, // containsErrorT3
+			latencyPointerT1,
+			latencyPointerT2,
+			latencyPointerT3,
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			funnelSteps[2].ServiceName, // serviceNameT1
+			funnelSteps[2].SpanName,    // spanNameT3
+			clauseStep1,
+			clauseStep2,
+			clauseStep3,
+		)
+	} else {
+		query = BuildTwoStepFunnelOverviewQuery(
+			containsErrorT1, // containsErrorT1
+			containsErrorT2, // containsErrorT2
+			latencyPointerT1,
+			latencyPointerT2,
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			clauseStep1,
+			clauseStep2,
+		)
+	}
+	return &v3.ClickHouseQuery{Query: query}, nil
+}
+
+func GetFunnelStepAnalytics(funnel *tracefunnel.Funnel, timeRange tracefunnel.TimeRange, stepStart, stepEnd int64) (*v3.ClickHouseQuery, error) {
+	var query string
+	var err error
+
+	funnelSteps := funnel.Steps
+	containsErrorT1 := 0
+	containsErrorT2 := 0
+	containsErrorT3 := 0
+	latencyPointerT1 := funnelSteps[0].LatencyPointer
+	latencyPointerT2 := funnelSteps[1].LatencyPointer
+	latencyPointerT3 := "start"
+	if len(funnel.Steps) > 2 {
+		latencyPointerT3 = funnelSteps[2].LatencyPointer
+	}
+	latencyTypeT2 := "p99"
+	latencyTypeT3 := "p99"
+
+	if stepStart == stepEnd {
+		return nil, fmt.Errorf("step start and end cannot be the same for /step/overview")
+	}
+
+	if funnelSteps[0].HasErrors {
+		containsErrorT1 = 1
+	}
+	if funnelSteps[1].HasErrors {
+		containsErrorT2 = 1
+	}
+	if len(funnel.Steps) > 2 && funnelSteps[2].HasErrors {
+		containsErrorT3 = 1
+	}
+
+	if funnelSteps[1].LatencyType != "" {
+		latencyTypeT2 = strings.ToLower(funnelSteps[1].LatencyType)
+	}
+	if len(funnel.Steps) > 2 && funnelSteps[2].LatencyType != "" {
+		latencyTypeT3 = strings.ToLower(funnelSteps[2].LatencyType)
+	}
+
+	// Build filter clauses for each step
+	clauseStep1, err := tracev4.BuildTracesFilterQuery(funnelSteps[0].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep2, err := tracev4.BuildTracesFilterQuery(funnelSteps[1].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep3 := ""
+	if len(funnel.Steps) > 2 {
+		clauseStep3, err = tracev4.BuildTracesFilterQuery(funnelSteps[2].Filters)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if len(funnel.Steps) > 2 {
+		query = BuildThreeStepFunnelStepOverviewQuery(
+			containsErrorT1, // containsErrorT1
+			containsErrorT2, // containsErrorT2
+			containsErrorT3, // containsErrorT3
+			latencyPointerT1,
+			latencyPointerT2,
+			latencyPointerT3,
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			funnelSteps[2].ServiceName, // serviceNameT1
+			funnelSteps[2].SpanName,    // spanNameT3
+			clauseStep1,
+			clauseStep2,
+			clauseStep3,
+			stepStart,
+			stepEnd,
+			latencyTypeT2,
+			latencyTypeT3,
+		)
+	} else {
+		query = BuildTwoStepFunnelStepOverviewQuery(
+			containsErrorT1, // containsErrorT1
+			containsErrorT2, // containsErrorT2
+			latencyPointerT1,
+			latencyPointerT2,
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			clauseStep1,
+			clauseStep2,
+			latencyTypeT2,
+		)
+	}
+	return &v3.ClickHouseQuery{Query: query}, nil
+}
+
+func GetStepAnalytics(funnel *tracefunnel.Funnel, timeRange tracefunnel.TimeRange) (*v3.ClickHouseQuery, error) {
+	var query string
+
+	funnelSteps := funnel.Steps
+	containsErrorT1 := 0
+	containsErrorT2 := 0
+	containsErrorT3 := 0
+
+	if funnelSteps[0].HasErrors {
+		containsErrorT1 = 1
+	}
+	if funnelSteps[1].HasErrors {
+		containsErrorT2 = 1
+	}
+	if len(funnel.Steps) > 2 && funnelSteps[2].HasErrors {
+		containsErrorT3 = 1
+	}
+
+	// Build filter clauses for each step
+	clauseStep1, err := tracev4.BuildTracesFilterQuery(funnelSteps[0].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep2, err := tracev4.BuildTracesFilterQuery(funnelSteps[1].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep3 := ""
+	if len(funnel.Steps) > 2 {
+		clauseStep3, err = tracev4.BuildTracesFilterQuery(funnelSteps[2].Filters)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if len(funnel.Steps) > 2 {
+		query = BuildThreeStepFunnelCountQuery(
+			containsErrorT1,            // containsErrorT1
+			containsErrorT2,            // containsErrorT2
+			containsErrorT3,            // containsErrorT3
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			funnelSteps[2].ServiceName, // serviceNameT1
+			funnelSteps[2].SpanName,    // spanNameT3
+			clauseStep1,
+			clauseStep2,
+			clauseStep3,
+		)
+	} else {
+		query = BuildTwoStepFunnelCountQuery(
+			containsErrorT1,            // containsErrorT1
+			containsErrorT2,            // containsErrorT2
+			timeRange.StartTime,        // startTs
+			timeRange.EndTime,          // endTs
+			funnelSteps[0].ServiceName, // serviceNameT1
+			funnelSteps[0].SpanName,    // spanNameT1
+			funnelSteps[1].ServiceName, // serviceNameT1
+			funnelSteps[1].SpanName,    // spanNameT2
+			clauseStep1,
+			clauseStep2,
+		)
+	}
+
+	return &v3.ClickHouseQuery{
+		Query: query,
+	}, nil
+}
+
+func GetSlowestTraces(funnel *tracefunnel.Funnel, timeRange tracefunnel.TimeRange, stepStart, stepEnd int64) (*v3.ClickHouseQuery, error) {
+	funnelSteps := funnel.Steps
+	containsErrorT1 := 0
+	containsErrorT2 := 0
+	stepStartOrder := 0
+	stepEndOrder := 1
+
+	if stepStart != stepEnd {
+		stepStartOrder = int(stepStart) - 1
+		stepEndOrder = int(stepEnd) - 1
+		if funnelSteps[stepStartOrder].HasErrors {
+			containsErrorT1 = 1
+		}
+		if funnelSteps[stepEndOrder].HasErrors {
+			containsErrorT2 = 1
+		}
+	}
+
+	// Build filter clauses for the steps
+	clauseStep1, err := tracev4.BuildTracesFilterQuery(funnelSteps[stepStartOrder].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep2, err := tracev4.BuildTracesFilterQuery(funnelSteps[stepEndOrder].Filters)
+	if err != nil {
+		return nil, err
+	}
+
+	query := BuildTwoStepFunnelTopSlowTracesQuery(
+		containsErrorT1,                         // containsErrorT1
+		containsErrorT2,                         // containsErrorT2
+		timeRange.StartTime,                     // startTs
+		timeRange.EndTime,                       // endTs
+		funnelSteps[stepStartOrder].ServiceName, // serviceNameT1
+		funnelSteps[stepStartOrder].SpanName,    // spanNameT1
+		funnelSteps[stepEndOrder].ServiceName,   // serviceNameT1
+		funnelSteps[stepEndOrder].SpanName,      // spanNameT2
+		clauseStep1,
+		clauseStep2,
+	)
+	return &v3.ClickHouseQuery{Query: query}, nil
+}
+
+func GetErroredTraces(funnel *tracefunnel.Funnel, timeRange tracefunnel.TimeRange, stepStart, stepEnd int64) (*v3.ClickHouseQuery, error) {
+	funnelSteps := funnel.Steps
+	containsErrorT1 := 0
+	containsErrorT2 := 0
+	stepStartOrder := 0
+	stepEndOrder := 1
+
+	if stepStart != stepEnd {
+		stepStartOrder = int(stepStart) - 1
+		stepEndOrder = int(stepEnd) - 1
+		if funnelSteps[stepStartOrder].HasErrors {
+			containsErrorT1 = 1
+		}
+		if funnelSteps[stepEndOrder].HasErrors {
+			containsErrorT2 = 1
+		}
+	}
+
+	// Build filter clauses for the steps
+	clauseStep1, err := tracev4.BuildTracesFilterQuery(funnelSteps[stepStartOrder].Filters)
+	if err != nil {
+		return nil, err
+	}
+	clauseStep2, err := tracev4.BuildTracesFilterQuery(funnelSteps[stepEndOrder].Filters)
+	if err != nil {
+		return nil, err
+	}
+
+	query := BuildTwoStepFunnelTopSlowErrorTracesQuery(
+		containsErrorT1,                         // containsErrorT1
+		containsErrorT2,                         // containsErrorT2
+		timeRange.StartTime,                     // startTs
+		timeRange.EndTime,                       // endTs
+		funnelSteps[stepStartOrder].ServiceName, // serviceNameT1
+		funnelSteps[stepStartOrder].SpanName,    // spanNameT1
+		funnelSteps[stepEndOrder].ServiceName,   // serviceNameT1
+		funnelSteps[stepEndOrder].SpanName,      // spanNameT2
+		clauseStep1,
+		clauseStep2,
+	)
+	return &v3.ClickHouseQuery{Query: query}, nil
+}

pkg/modules/tracefunnel/tracefunnel.go

@@ -0,0 +1,41 @@
+package tracefunnel
+
+import (
+	"context"
+	"net/http"
+
+	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunnel"
+)
+
+// Module defines the interface for trace funnel operations
+type Module interface {
+	Create(ctx context.Context, timestamp int64, name string, userID string, orgID string) (*traceFunnels.Funnel, error)
+
+	Get(ctx context.Context, funnelID string) (*traceFunnels.Funnel, error)
+
+	Update(ctx context.Context, funnel *traceFunnels.Funnel, userID string) error
+
+	List(ctx context.Context, orgID string) ([]*traceFunnels.Funnel, error)
+
+	Delete(ctx context.Context, funnelID string) error
+
+	Save(ctx context.Context, funnel *traceFunnels.Funnel, userID string, orgID string) error
+
+	GetFunnelMetadata(ctx context.Context, funnelID string) (int64, int64, string, error)
+}
+
+type Handler interface {
+	New(http.ResponseWriter, *http.Request)
+
+	UpdateSteps(http.ResponseWriter, *http.Request)
+
+	UpdateFunnel(http.ResponseWriter, *http.Request)
+
+	List(http.ResponseWriter, *http.Request)
+
+	Get(http.ResponseWriter, *http.Request)
+
+	Delete(http.ResponseWriter, *http.Request)
+
+	Save(http.ResponseWriter, *http.Request)
+}

pkg/modules/tracefunnel/utils.go

@@ -0,0 +1,132 @@
+package tracefunnel
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// ValidateTimestamp validates a timestamp
+func ValidateTimestamp(timestamp int64, fieldName string) error {
+	if timestamp == 0 {
+		return fmt.Errorf("%s is required", fieldName)
+	}
+	if timestamp < 0 {
+		return fmt.Errorf("%s must be positive", fieldName)
+	}
+	return nil
+}
+
+// ValidateTimestampIsMilliseconds validates that a timestamp is in milliseconds
+func ValidateTimestampIsMilliseconds(timestamp int64) bool {
+	return timestamp >= 1000000000000 && timestamp <= 9999999999999
+}
+
+func ValidateFunnelSteps(steps []tracefunnel.FunnelStep) error {
+	if len(steps) < 2 {
+		return fmt.Errorf("funnel must have at least 2 steps")
+	}
+
+	for i, step := range steps {
+		if step.ServiceName == "" {
+			return fmt.Errorf("step %d: service name is required", i+1)
+		}
+		if step.SpanName == "" {
+			return fmt.Errorf("step %d: span name is required", i+1)
+		}
+		if step.Order < 0 {
+			return fmt.Errorf("step %d: order must be non-negative", i+1)
+		}
+	}
+
+	return nil
+}
+
+// NormalizeFunnelSteps normalizes step orders to be sequential starting from 1.
+// Returns a new slice with normalized step orders, leaving the input slice unchanged.
+func NormalizeFunnelSteps(steps []tracefunnel.FunnelStep) []tracefunnel.FunnelStep {
+	if len(steps) == 0 {
+		return []tracefunnel.FunnelStep{}
+	}
+
+	newSteps := make([]tracefunnel.FunnelStep, len(steps))
+	copy(newSteps, steps)
+
+	sort.Slice(newSteps, func(i, j int) bool {
+		return newSteps[i].Order < newSteps[j].Order
+	})
+
+	for i := range newSteps {
+		newSteps[i].Order = int64(i + 1)
+	}
+
+	return newSteps
+}
+
+func GetClaims(r *http.Request) (*authtypes.Claims, error) {
+	claims, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		return nil, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"unauthenticated")
+	}
+	return &claims, nil
+}
+
+func ValidateAndConvertTimestamp(timestamp int64) (time.Time, error) {
+	if err := ValidateTimestamp(timestamp, "timestamp"); err != nil {
+		return time.Time{}, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"timestamp is invalid: %v", err)
+	}
+	return time.Unix(0, timestamp*1000000), nil // Convert to nanoseconds
+}
+
+func ConstructFunnelResponse(funnel *tracefunnel.Funnel, claims *authtypes.Claims) tracefunnel.FunnelResponse {
+	resp := tracefunnel.FunnelResponse{
+		FunnelName:  funnel.Name,
+		FunnelID:    funnel.ID.String(),
+		Steps:       funnel.Steps,
+		CreatedAt:   funnel.CreatedAt.UnixNano() / 1000000,
+		CreatedBy:   funnel.CreatedBy,
+		OrgID:       funnel.OrgID.String(),
+		UpdatedBy:   funnel.UpdatedBy,
+		UpdatedAt:   funnel.UpdatedAt.UnixNano() / 1000000,
+		Description: funnel.Description,
+	}
+
+	if funnel.CreatedByUser != nil {
+		resp.UserEmail = funnel.CreatedByUser.Email
+	} else if claims != nil {
+		resp.UserEmail = claims.Email
+	}
+
+	return resp
+}
+
+func ProcessFunnelSteps(steps []tracefunnel.FunnelStep) ([]tracefunnel.FunnelStep, error) {
+	// First validate the steps
+	if err := ValidateFunnelSteps(steps); err != nil {
+		return nil, errors.Newf(errors.TypeInvalidInput,
+			errors.CodeInvalidInput,
+			"invalid funnel steps: %v", err)
+	}
+
+	// Then process the steps
+	for i := range steps {
+		if steps[i].Order < 1 {
+			steps[i].Order = int64(i + 1)
+		}
+		if steps[i].ID.IsZero() {
+			steps[i].ID = valuer.GenerateUUID()
+		}
+	}
+
+	return NormalizeFunnelSteps(steps), nil
+}

pkg/modules/tracefunnel/utils_test.go

@@ -0,0 +1,657 @@
+package tracefunnel
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestValidateTimestamp(t *testing.T) {
+	tests := []struct {
+		name        string
+		timestamp   int64
+		fieldName   string
+		expectError bool
+	}{
+		{
+			name:        "valid timestamp",
+			timestamp:   time.Now().UnixMilli(),
+			fieldName:   "timestamp",
+			expectError: false,
+		},
+		{
+			name:        "zero timestamp",
+			timestamp:   0,
+			fieldName:   "timestamp",
+			expectError: true,
+		},
+		{
+			name:        "negative timestamp",
+			timestamp:   -1,
+			fieldName:   "timestamp",
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := ValidateTimestamp(tt.timestamp, tt.fieldName)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestValidateTimestampIsMilliseconds(t *testing.T) {
+	tests := []struct {
+		name      string
+		timestamp int64
+		expected  bool
+	}{
+		{
+			name:      "valid millisecond timestamp",
+			timestamp: 1700000000000, // 2023-11-14 12:00:00 UTC
+			expected:  true,
+		},
+		{
+			name:      "too small timestamp",
+			timestamp: 999999999999,
+			expected:  false,
+		},
+		{
+			name:      "too large timestamp",
+			timestamp: 10000000000000,
+			expected:  false,
+		},
+		{
+			name:      "second precision timestamp",
+			timestamp: 1700000000,
+			expected:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ValidateTimestampIsMilliseconds(tt.timestamp)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestValidateFunnelSteps(t *testing.T) {
+	tests := []struct {
+		name        string
+		steps       []tracefunnel.FunnelStep
+		expectError bool
+	}{
+		{
+			name: "valid steps",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expectError: false,
+		},
+		{
+			name: "too few steps",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+			},
+			expectError: true,
+		},
+		{
+			name: "missing service name",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:       valuer.GenerateUUID(),
+					Name:     "Step 1",
+					SpanName: "test-span",
+					Order:    1,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expectError: true,
+		},
+		{
+			name: "missing span name",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					Order:       1,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expectError: true,
+		},
+		{
+			name: "negative order",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       -1,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := ValidateFunnelSteps(tt.steps)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestNormalizeFunnelSteps(t *testing.T) {
+	tests := []struct {
+		name     string
+		steps    []tracefunnel.FunnelStep
+		expected []tracefunnel.FunnelStep
+	}{
+		{
+			name: "already normalized steps",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expected: []tracefunnel.FunnelStep{
+				{
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+				{
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+		},
+		{
+			name: "unordered steps",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+			},
+			expected: []tracefunnel.FunnelStep{
+				{
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+				{
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+		},
+		{
+			name: "steps with gaps in order",
+			steps: []tracefunnel.FunnelStep{
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 3",
+					ServiceName: "test-service",
+					SpanName:    "test-span-3",
+					Order:       3,
+				},
+				{
+					ID:          valuer.GenerateUUID(),
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expected: []tracefunnel.FunnelStep{
+				{
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       1,
+				},
+				{
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+				{
+					Name:        "Step 3",
+					ServiceName: "test-service",
+					SpanName:    "test-span-3",
+					Order:       3,
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Make a copy of the steps to avoid modifying the original
+			steps := make([]tracefunnel.FunnelStep, len(tt.steps))
+			copy(steps, tt.steps)
+
+			result := NormalizeFunnelSteps(steps)
+
+			// Compare only the relevant fields
+			for i := range result {
+				assert.Equal(t, tt.expected[i].Name, result[i].Name)
+				assert.Equal(t, tt.expected[i].ServiceName, result[i].ServiceName)
+				assert.Equal(t, tt.expected[i].SpanName, result[i].SpanName)
+				assert.Equal(t, tt.expected[i].Order, result[i].Order)
+			}
+		})
+	}
+}
+
+func TestGetClaims(t *testing.T) {
+	tests := []struct {
+		name        string
+		setup       func(*http.Request)
+		expectError bool
+	}{
+		{
+			name: "valid claims",
+			setup: func(r *http.Request) {
+				claims := authtypes.Claims{
+					UserID: "user-123",
+					OrgID:  "org-123",
+					Email:  "test@example.com",
+				}
+				*r = *r.WithContext(authtypes.NewContextWithClaims(r.Context(), claims))
+			},
+			expectError: false,
+		},
+		{
+			name:        "no claims in context",
+			setup:       func(r *http.Request) {},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest("GET", "/", nil)
+			tt.setup(req)
+
+			claims, err := GetClaims(req)
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Nil(t, claims)
+			} else {
+				assert.NoError(t, err)
+				assert.NotNil(t, claims)
+				assert.Equal(t, "user-123", claims.UserID)
+				assert.Equal(t, "org-123", claims.OrgID)
+				assert.Equal(t, "test@example.com", claims.Email)
+			}
+		})
+	}
+}
+
+func TestValidateAndConvertTimestamp(t *testing.T) {
+	tests := []struct {
+		name        string
+		timestamp   int64
+		expectError bool
+	}{
+		{
+			name:        "valid timestamp",
+			timestamp:   time.Now().UnixMilli(),
+			expectError: false,
+		},
+		{
+			name:        "zero timestamp",
+			timestamp:   0,
+			expectError: true,
+		},
+		{
+			name:        "negative timestamp",
+			timestamp:   -1,
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := ValidateAndConvertTimestamp(tt.timestamp)
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.True(t, result.IsZero())
+			} else {
+				assert.NoError(t, err)
+				assert.False(t, result.IsZero())
+				// Verify the conversion from milliseconds to nanoseconds
+				assert.Equal(t, tt.timestamp*1000000, result.UnixNano())
+			}
+		})
+	}
+}
+
+func TestConstructFunnelResponse(t *testing.T) {
+	now := time.Now()
+	funnelID := valuer.GenerateUUID()
+	orgID := valuer.GenerateUUID()
+
+	tests := []struct {
+		name     string
+		funnel   *tracefunnel.Funnel
+		claims   *authtypes.Claims
+		expected tracefunnel.FunnelResponse
+	}{
+		{
+			name: "with user email from funnel",
+			funnel: &tracefunnel.Funnel{
+				BaseMetadata: tracefunnel.BaseMetadata{
+					Identifiable: types.Identifiable{
+						ID: funnelID,
+					},
+					Name:  "test-funnel",
+					OrgID: orgID,
+					TimeAuditable: types.TimeAuditable{
+						CreatedAt: now,
+						UpdatedAt: now,
+					},
+					UserAuditable: types.UserAuditable{
+						CreatedBy: "user-123",
+						UpdatedBy: "user-123",
+					},
+				},
+				CreatedByUser: &types.User{
+					ID:    "user-123",
+					Email: "funnel@example.com",
+				},
+				Steps: []tracefunnel.FunnelStep{
+					{
+						ID:          valuer.GenerateUUID(),
+						Name:        "Step 1",
+						ServiceName: "test-service",
+						SpanName:    "test-span",
+						Order:       1,
+					},
+				},
+			},
+			claims: &authtypes.Claims{
+				UserID: "user-123",
+				OrgID:  orgID.String(),
+				Email:  "claims@example.com",
+			},
+			expected: tracefunnel.FunnelResponse{
+				FunnelName: "test-funnel",
+				FunnelID:   funnelID.String(),
+				Steps: []tracefunnel.FunnelStep{
+					{
+						Name:        "Step 1",
+						ServiceName: "test-service",
+						SpanName:    "test-span",
+						Order:       1,
+					},
+				},
+				CreatedAt: now.UnixNano() / 1000000,
+				CreatedBy: "user-123",
+				UpdatedAt: now.UnixNano() / 1000000,
+				UpdatedBy: "user-123",
+				OrgID:     orgID.String(),
+				UserEmail: "funnel@example.com",
+			},
+		},
+		{
+			name: "with user email from claims",
+			funnel: &tracefunnel.Funnel{
+				BaseMetadata: tracefunnel.BaseMetadata{
+					Identifiable: types.Identifiable{
+						ID: funnelID,
+					},
+					Name:  "test-funnel",
+					OrgID: orgID,
+					TimeAuditable: types.TimeAuditable{
+						CreatedAt: now,
+						UpdatedAt: now,
+					},
+					UserAuditable: types.UserAuditable{
+						CreatedBy: "user-123",
+						UpdatedBy: "user-123",
+					},
+				},
+				Steps: []tracefunnel.FunnelStep{
+					{
+						ID:          valuer.GenerateUUID(),
+						Name:        "Step 1",
+						ServiceName: "test-service",
+						SpanName:    "test-span",
+						Order:       1,
+					},
+				},
+			},
+			claims: &authtypes.Claims{
+				UserID: "user-123",
+				OrgID:  orgID.String(),
+				Email:  "claims@example.com",
+			},
+			expected: tracefunnel.FunnelResponse{
+				FunnelName: "test-funnel",
+				FunnelID:   funnelID.String(),
+				Steps: []tracefunnel.FunnelStep{
+					{
+						Name:        "Step 1",
+						ServiceName: "test-service",
+						SpanName:    "test-span",
+						Order:       1,
+					},
+				},
+				CreatedAt: now.UnixNano() / 1000000,
+				CreatedBy: "user-123",
+				UpdatedAt: now.UnixNano() / 1000000,
+				UpdatedBy: "user-123",
+				OrgID:     orgID.String(),
+				UserEmail: "claims@example.com",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ConstructFunnelResponse(tt.funnel, tt.claims)
+
+			// Compare top-level fields
+			assert.Equal(t, tt.expected.FunnelName, result.FunnelName)
+			assert.Equal(t, tt.expected.FunnelID, result.FunnelID)
+			assert.Equal(t, tt.expected.CreatedAt, result.CreatedAt)
+			assert.Equal(t, tt.expected.CreatedBy, result.CreatedBy)
+			assert.Equal(t, tt.expected.UpdatedAt, result.UpdatedAt)
+			assert.Equal(t, tt.expected.UpdatedBy, result.UpdatedBy)
+			assert.Equal(t, tt.expected.OrgID, result.OrgID)
+			assert.Equal(t, tt.expected.UserEmail, result.UserEmail)
+
+			// Compare steps
+			assert.Len(t, result.Steps, len(tt.expected.Steps))
+			for i, step := range result.Steps {
+				expectedStep := tt.expected.Steps[i]
+				assert.Equal(t, expectedStep.Name, step.Name)
+				assert.Equal(t, expectedStep.ServiceName, step.ServiceName)
+				assert.Equal(t, expectedStep.SpanName, step.SpanName)
+				assert.Equal(t, expectedStep.Order, step.Order)
+			}
+		})
+	}
+}
+
+func TestProcessFunnelSteps(t *testing.T) {
+	tests := []struct {
+		name        string
+		steps       []tracefunnel.FunnelStep
+		expectError bool
+	}{
+		{
+			name: "valid steps with missing IDs",
+			steps: []tracefunnel.FunnelStep{
+				{
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       0, // Will be normalized to 1
+				},
+				{
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       0, // Will be normalized to 2
+				},
+			},
+			expectError: false,
+		},
+		{
+			name: "invalid steps - missing service name",
+			steps: []tracefunnel.FunnelStep{
+				{
+					Name:     "Step 1",
+					SpanName: "test-span",
+					Order:    1,
+				},
+				{
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expectError: true,
+		},
+		{
+			name: "invalid steps - negative order",
+			steps: []tracefunnel.FunnelStep{
+				{
+					Name:        "Step 1",
+					ServiceName: "test-service",
+					SpanName:    "test-span",
+					Order:       -1,
+				},
+				{
+					Name:        "Step 2",
+					ServiceName: "test-service",
+					SpanName:    "test-span-2",
+					Order:       2,
+				},
+			},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := ProcessFunnelSteps(tt.steps)
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Nil(t, result)
+			} else {
+				assert.NoError(t, err)
+				assert.NotNil(t, result)
+				assert.Len(t, result, len(tt.steps))
+
+				// Verify IDs are generated
+				for _, step := range result {
+					assert.False(t, step.ID.IsZero())
+				}
+
+				// Verify orders are normalized
+				for i, step := range result {
+					assert.Equal(t, int64(i+1), step.Order)
+				}
+			}
+		})
+	}
+}

pkg/query-service/app/cloudintegrations/availableServices.go

@@ -1,4 +1,4 @@
-package services
+package cloudintegrations
 
 import (
 	"bytes"
@@ -9,25 +9,17 @@ import (
 	"path"
 	"sort"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	koanfJson "github.com/knadh/koanf/parsers/json"
 	"golang.org/x/exp/maps"
 )
 
-const (
-	S3Sync = "s3sync"
-)
-
-var (
-	CodeUnsupportedCloudProvider = errors.MustNewCode("unsupported_cloud_provider")
-	CodeUnsupportedServiceType   = errors.MustNewCode("unsupported_service_type")
-)
-
-func List(cloudProvider string) ([]Definition, *model.ApiError) {
-	cloudServices, found := supportedServices[cloudProvider]
-	if !found || cloudServices == nil {
+func listCloudProviderServices(
+	cloudProvider string,
+) ([]CloudServiceDetails, *model.ApiError) {
+	cloudServices := availableServices[cloudProvider]
+	if cloudServices == nil {
 		return nil, model.NotFoundError(fmt.Errorf(
 			"unsupported cloud provider: %s", cloudProvider,
 		))
@@ -41,24 +33,21 @@ func List(cloudProvider string) ([]Definition, *model.ApiError) {
 	return services, nil
 }
 
-func Map(cloudProvider string) (map[string]Definition, error) {
-	cloudServices, found := supportedServices[cloudProvider]
-	if !found || cloudServices == nil {
-		return nil, errors.Newf(errors.TypeNotFound, CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", cloudProvider)
-	}
-
-	return cloudServices, nil
-}
-
-func GetServiceDefinition(cloudProvider, serviceType string) (*Definition, error) {
-	cloudServices := supportedServices[cloudProvider]
+func getCloudProviderService(
+	cloudProvider string, serviceId string,
+) (*CloudServiceDetails, *model.ApiError) {
+	cloudServices := availableServices[cloudProvider]
 	if cloudServices == nil {
-		return nil, errors.Newf(errors.TypeNotFound, CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", cloudProvider)
+		return nil, model.NotFoundError(fmt.Errorf(
+			"unsupported cloud provider: %s", cloudProvider,
+		))
 	}
 
-	svc, exists := cloudServices[serviceType]
+	svc, exists := cloudServices[serviceId]
 	if !exists {
-		return nil, errors.Newf(errors.TypeNotFound, CodeUnsupportedServiceType, "%s service not found: %s", cloudProvider, serviceType)
+		return nil, model.NotFoundError(fmt.Errorf(
+			"%s service not found: %s", cloudProvider, serviceId,
+		))
 	}
 
 	return &svc, nil
@@ -68,7 +57,7 @@ func GetServiceDefinition(cloudProvider, serviceType string) (*Definition, error
 
 // Service details read from ./serviceDefinitions
 // { "providerName": { "service_id": {...}} }
-var supportedServices map[string]map[string]Definition
+var availableServices map[string]map[string]CloudServiceDetails
 
 func init() {
 	err := readAllServiceDefinitions()
@@ -79,15 +68,15 @@ func init() {
 	}
 }
 
-//go:embed definitions/*
-var definitionFiles embed.FS
+//go:embed serviceDefinitions/*
+var serviceDefinitionFiles embed.FS
 
 func readAllServiceDefinitions() error {
-	supportedServices = map[string]map[string]Definition{}
+	availableServices = map[string]map[string]CloudServiceDetails{}
 
-	rootDirName := "definitions"
+	rootDirName := "serviceDefinitions"
 
-	cloudProviderDirs, err := fs.ReadDir(definitionFiles, rootDirName)
+	cloudProviderDirs, err := fs.ReadDir(serviceDefinitionFiles, rootDirName)
 	if err != nil {
 		return fmt.Errorf("couldn't read dirs in %s: %w", rootDirName, err)
 	}
@@ -109,21 +98,21 @@ func readAllServiceDefinitions() error {
 			return fmt.Errorf("no %s services could be read", cloudProvider)
 		}
 
-		supportedServices[cloudProvider] = cloudServices
+		availableServices[cloudProvider] = cloudServices
 	}
 
 	return nil
 }
 
 func readServiceDefinitionsFromDir(cloudProvider string, cloudProviderDirPath string) (
-	map[string]Definition, error,
+	map[string]CloudServiceDetails, error,
 ) {
-	svcDefDirs, err := fs.ReadDir(definitionFiles, cloudProviderDirPath)
+	svcDefDirs, err := fs.ReadDir(serviceDefinitionFiles, cloudProviderDirPath)
 	if err != nil {
 		return nil, fmt.Errorf("couldn't list integrations dirs: %w", err)
 	}
 
-	svcDefs := map[string]Definition{}
+	svcDefs := map[string]CloudServiceDetails{}
 
 	for _, d := range svcDefDirs {
 		if !d.IsDir() {
@@ -148,10 +137,10 @@ func readServiceDefinitionsFromDir(cloudProvider string, cloudProviderDirPath st
 	return svcDefs, nil
 }
 
-func readServiceDefinition(cloudProvider string, svcDirpath string) (*Definition, error) {
+func readServiceDefinition(cloudProvider string, svcDirpath string) (*CloudServiceDetails, error) {
 	integrationJsonPath := path.Join(svcDirpath, "integration.json")
 
-	serializedSpec, err := definitionFiles.ReadFile(integrationJsonPath)
+	serializedSpec, err := serviceDefinitionFiles.ReadFile(integrationJsonPath)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"couldn't find integration.json in %s: %w",
@@ -168,7 +157,7 @@ func readServiceDefinition(cloudProvider string, svcDirpath string) (*Definition
 	}
 
 	hydrated, err := integrations.HydrateFileUris(
-		integrationSpec, definitionFiles, svcDirpath,
+		integrationSpec, serviceDefinitionFiles, svcDirpath,
 	)
 	if err != nil {
 		return nil, fmt.Errorf(
@@ -178,7 +167,7 @@ func readServiceDefinition(cloudProvider string, svcDirpath string) (*Definition
 	}
 	hydratedSpec := hydrated.(map[string]any)
 
-	serviceDef, err := ParseStructWithJsonTagsFromMap[Definition](hydratedSpec)
+	serviceDef, err := ParseStructWithJsonTagsFromMap[CloudServiceDetails](hydratedSpec)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"couldn't parse hydrated JSON spec read from %s: %w",
@@ -191,13 +180,13 @@ func readServiceDefinition(cloudProvider string, svcDirpath string) (*Definition
 		return nil, fmt.Errorf("invalid service definition %s: %w", serviceDef.Id, err)
 	}
 
-	serviceDef.Strategy.Provider = cloudProvider
+	serviceDef.TelemetryCollectionStrategy.Provider = cloudProvider
 
 	return serviceDef, nil
 
 }
 
-func validateServiceDefinition(s *Definition) error {
+func validateServiceDefinition(s *CloudServiceDetails) error {
 	// Validate dashboard data
 	seenDashboardIds := map[string]interface{}{}
 	for _, dd := range s.Assets.Dashboards {
@@ -207,7 +196,7 @@ func validateServiceDefinition(s *Definition) error {
 		seenDashboardIds[dd.Id] = nil
 	}
 
-	if s.Strategy == nil {
+	if s.TelemetryCollectionStrategy == nil {
 		return fmt.Errorf("telemetry_collection_strategy is required")
 	}
 

pkg/query-service/app/cloudintegrations/availableServices_test.go

@@ -1,9 +1,8 @@
-package services
+package cloudintegrations
 
 import (
 	"testing"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/stretchr/testify/require"
 )
@@ -12,24 +11,24 @@ func TestAvailableServices(t *testing.T) {
 	require := require.New(t)
 
 	// should be able to list available services.
-	_, apiErr := List("bad-cloud-provider")
+	_, apiErr := listCloudProviderServices("bad-cloud-provider")
 	require.NotNil(apiErr)
 	require.Equal(model.ErrorNotFound, apiErr.Type())
 
-	awsSvcs, apiErr := List("aws")
+	awsSvcs, apiErr := listCloudProviderServices("aws")
 	require.Nil(apiErr)
 	require.Greater(len(awsSvcs), 0)
 
 	// should be able to get details of a service
-	_, err := GetServiceDefinition(
+	_, apiErr = getCloudProviderService(
 		"aws", "bad-service-id",
 	)
-	require.NotNil(err)
-	require.True(errors.Ast(err, errors.TypeNotFound))
+	require.NotNil(apiErr)
+	require.Equal(model.ErrorNotFound, apiErr.Type())
 
-	svc, err := GetServiceDefinition(
+	svc, apiErr := getCloudProviderService(
 		"aws", awsSvcs[0].Id,
 	)
-	require.Nil(err)
+	require.Nil(apiErr)
 	require.Equal(*svc, awsSvcs[0])
 }

pkg/query-service/app/cloudintegrations/constants.go

@@ -1,44 +0,0 @@
-package cloudintegrations
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/aws/aws-sdk-go/aws/endpoints"
-)
-
-var (
-	CodeInvalidCloudRegion    = errors.MustNewCode("invalid_cloud_region")
-	CodeMismatchCloudProvider = errors.MustNewCode("cloud_provider_mismatch")
-)
-
-// List of all valid cloud regions on Amazon Web Services
-var ValidAWSRegions = map[string]bool{
-	endpoints.AfSouth1RegionID:     true,
-	endpoints.ApEast1RegionID:      true,
-	endpoints.ApNortheast1RegionID: true,
-	endpoints.ApNortheast2RegionID: true,
-	endpoints.ApNortheast3RegionID: true,
-	endpoints.ApSouth1RegionID:     true,
-	endpoints.ApSouth2RegionID:     true,
-	endpoints.ApSoutheast1RegionID: true,
-	endpoints.ApSoutheast2RegionID: true,
-	endpoints.ApSoutheast3RegionID: true,
-	endpoints.ApSoutheast4RegionID: true,
-	endpoints.CaCentral1RegionID:   true,
-	endpoints.CaWest1RegionID:      true,
-	endpoints.EuCentral1RegionID:   true,
-	endpoints.EuCentral2RegionID:   true,
-	endpoints.EuNorth1RegionID:     true,
-	endpoints.EuSouth1RegionID:     true,
-	endpoints.EuSouth2RegionID:     true,
-	endpoints.EuWest1RegionID:      true,
-	endpoints.EuWest2RegionID:      true,
-	endpoints.EuWest3RegionID:      true,
-	endpoints.IlCentral1RegionID:   true,
-	endpoints.MeCentral1RegionID:   true,
-	endpoints.MeSouth1RegionID:     true,
-	endpoints.SaEast1RegionID:      true,
-	endpoints.UsEast1RegionID:      true,
-	endpoints.UsEast2RegionID:      true,
-	endpoints.UsWest1RegionID:      true,
-	endpoints.UsWest2RegionID:      true,
-}

pkg/query-service/app/cloudintegrations/controller.go

@@ -8,8 +8,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -29,7 +27,7 @@ func validateCloudProviderName(name string) *model.ApiError {
 
 type Controller struct {
 	accountsRepo      cloudProviderAccountsRepository
-	serviceConfigRepo ServiceConfigDatabase
+	serviceConfigRepo serviceConfigRepository
 }
 
 func NewController(sqlStore sqlstore.SQLStore) (
@@ -119,7 +117,7 @@ func (c *Controller) GenerateConnectionUrl(
 	}
 
 	// TODO(Raj): parameterized this in follow up changes
-	agentVersion := "v0.0.4"
+	agentVersion := "0.0.3"
 
 	connectionUrl := fmt.Sprintf(
 		"https://%s.console.aws.amazon.com/cloudformation/home?region=%s#/stacks/quickcreate?",
@@ -195,12 +193,12 @@ type AgentCheckInResponse struct {
 type IntegrationConfigForAgent struct {
 	EnabledRegions []string `json:"enabled_regions"`
 
-	TelemetryCollectionStrategy *CompiledCollectionStrategy `json:"telemetry,omitempty"`
+	TelemetryCollectionStrategy *CloudTelemetryCollectionStrategy `json:"telemetry,omitempty"`
 }
 
 func (c *Controller) CheckInAsAgent(
 	ctx context.Context, orgId string, cloudProvider string, req AgentCheckInRequest,
-) (*AgentCheckInResponse, error) {
+) (*AgentCheckInResponse, *model.ApiError) {
 	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
 		return nil, apiErr
 	}
@@ -234,7 +232,7 @@ func (c *Controller) CheckInAsAgent(
 	}
 
 	// prepare and return integration config to be consumed by agent
-	compiledStrategy, err := NewCompiledCollectionStrategy(cloudProvider)
+	telemetryCollectionStrategy, err := NewCloudTelemetryCollectionStrategy(cloudProvider)
 	if err != nil {
 		return nil, model.InternalError(fmt.Errorf(
 			"couldn't init telemetry collection strategy: %w", err,
@@ -243,16 +241,20 @@ func (c *Controller) CheckInAsAgent(
 
 	agentConfig := IntegrationConfigForAgent{
 		EnabledRegions:              []string{},
-		TelemetryCollectionStrategy: compiledStrategy,
+		TelemetryCollectionStrategy: telemetryCollectionStrategy,
 	}
 
 	if account.Config != nil && account.Config.EnabledRegions != nil {
 		agentConfig.EnabledRegions = account.Config.EnabledRegions
 	}
 
-	services, err := services.Map(cloudProvider)
-	if err != nil {
-		return nil, err
+	services, apiErr := listCloudProviderServices(cloudProvider)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "couldn't list cloud services")
+	}
+	svcDetailsById := map[string]*CloudServiceDetails{}
+	for _, svcDetails := range services {
+		svcDetailsById[svcDetails.Id] = &svcDetails
 	}
 
 	svcConfigs, apiErr := c.serviceConfigRepo.getAllForAccount(
@@ -265,19 +267,26 @@ func (c *Controller) CheckInAsAgent(
 	}
 
 	// accumulate config in a fixed order to ensure same config generated across runs
-	configuredServices := maps.Keys(svcConfigs)
-	slices.Sort(configuredServices)
+	configuredSvcIds := maps.Keys(svcConfigs)
+	slices.Sort(configuredSvcIds)
 
-	for _, svcType := range configuredServices {
-		definition, ok := services[svcType]
-		if !ok {
-			continue
-		}
-		config := svcConfigs[svcType]
+	for _, svcId := range configuredSvcIds {
+		svcDetails := svcDetailsById[svcId]
+		svcConfig := svcConfigs[svcId]
 
-		err := AddServiceStrategy(svcType, compiledStrategy, definition.Strategy, config)
-		if err != nil {
-			return nil, err
+		if svcDetails != nil {
+			metricsEnabled := svcConfig.Metrics != nil && svcConfig.Metrics.Enabled
+			logsEnabled := svcConfig.Logs != nil && svcConfig.Logs.Enabled
+			if logsEnabled || metricsEnabled {
+				err := agentConfig.TelemetryCollectionStrategy.AddServiceStrategy(
+					svcDetails.TelemetryCollectionStrategy, logsEnabled, metricsEnabled,
+				)
+				if err != nil {
+					return nil, model.InternalError(fmt.Errorf(
+						"couldn't add service telemetry collection strategy: %w", err,
+					))
+				}
+			}
 		}
 	}
 
@@ -340,7 +349,7 @@ func (c *Controller) DisconnectAccount(
 }
 
 type ListServicesResponse struct {
-	Services []ServiceSummary `json:"services"`
+	Services []CloudServiceSummary `json:"services"`
 }
 
 func (c *Controller) ListServices(
@@ -349,11 +358,12 @@ func (c *Controller) ListServices(
 	cloudProvider string,
 	cloudAccountId *string,
 ) (*ListServicesResponse, *model.ApiError) {
+
 	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
 		return nil, apiErr
 	}
 
-	definitions, apiErr := services.List(cloudProvider)
+	services, apiErr := listCloudProviderServices(cloudProvider)
 	if apiErr != nil {
 		return nil, model.WrapApiError(apiErr, "couldn't list cloud services")
 	}
@@ -376,11 +386,9 @@ func (c *Controller) ListServices(
 		}
 	}
 
-	summaries := []ServiceSummary{}
-	for _, def := range definitions {
-		summary := ServiceSummary{
-			Metadata: def.Metadata,
-		}
+	summaries := []CloudServiceSummary{}
+	for _, s := range services {
+		summary := s.CloudServiceSummary
 		summary.Config = svcConfigs[summary.Id]
 
 		summaries = append(summaries, summary)
@@ -397,18 +405,15 @@ func (c *Controller) GetServiceDetails(
 	cloudProvider string,
 	serviceId string,
 	cloudAccountId *string,
-) (*ServiceDetails, error) {
+) (*CloudServiceDetails, *model.ApiError) {
+
 	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
 		return nil, apiErr
 	}
 
-	definition, err := services.GetServiceDefinition(cloudProvider, serviceId)
-	if err != nil {
-		return nil, err
-	}
-
-	details := ServiceDetails{
-		Definition: *definition,
+	service, apiErr := getCloudProviderService(cloudProvider, serviceId)
+	if apiErr != nil {
+		return nil, apiErr
 	}
 
 	if cloudAccountId != nil {
@@ -428,7 +433,7 @@ func (c *Controller) GetServiceDetails(
 		}
 
 		if config != nil {
-			details.Config = config
+			service.Config = config
 
 			enabled := false
 			if config.Metrics != nil && config.Metrics.Enabled {
@@ -436,20 +441,22 @@ func (c *Controller) GetServiceDetails(
 			}
 
 			// add links to service dashboards, making them clickable.
-			for i, d := range definition.Assets.Dashboards {
+			for i, d := range service.Assets.Dashboards {
 				dashboardUuid := c.dashboardUuid(
 					cloudProvider, serviceId, d.Id,
 				)
 				if enabled {
-					definition.Assets.Dashboards[i].Url = fmt.Sprintf("/dashboard/%s", dashboardUuid)
+					service.Assets.Dashboards[i].Url = fmt.Sprintf(
+						"/dashboard/%s", dashboardUuid,
+					)
 				} else {
-					definition.Assets.Dashboards[i].Url = "" // to unset the in-memory URL if enabled once and disabled afterwards
+					service.Assets.Dashboards[i].Url = ""
 				}
 			}
 		}
 	}
 
-	return &details, nil
+	return service, nil
 }
 
 type UpdateServiceConfigRequest struct {
@@ -457,20 +464,6 @@ type UpdateServiceConfigRequest struct {
 	Config         types.CloudServiceConfig `json:"config"`
 }
 
-func (u *UpdateServiceConfigRequest) Validate(def *services.Definition) error {
-	if def.Id != services.S3Sync && u.Config.Logs != nil && u.Config.Logs.S3Buckets != nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "s3 buckets can only be added to service-type[%s]", services.S3Sync)
-	} else if def.Id == services.S3Sync && u.Config.Logs != nil && u.Config.Logs.S3Buckets != nil {
-		for region := range u.Config.Logs.S3Buckets {
-			if _, found := ValidAWSRegions[region]; !found {
-				return errors.NewInvalidInputf(CodeInvalidCloudRegion, "invalid cloud region: %s", region)
-			}
-		}
-	}
-
-	return nil
-}
-
 type UpdateServiceConfigResponse struct {
 	Id     string                   `json:"id"`
 	Config types.CloudServiceConfig `json:"config"`
@@ -480,23 +473,14 @@ func (c *Controller) UpdateServiceConfig(
 	ctx context.Context,
 	orgID string,
 	cloudProvider string,
-	serviceType string,
-	req *UpdateServiceConfigRequest,
-) (*UpdateServiceConfigResponse, error) {
+	serviceId string,
+	req UpdateServiceConfigRequest,
+) (*UpdateServiceConfigResponse, *model.ApiError) {
+
 	if apiErr := validateCloudProviderName(cloudProvider); apiErr != nil {
 		return nil, apiErr
 	}
 
-	// can only update config for a valid service.
-	definition, err := services.GetServiceDefinition(cloudProvider, serviceType)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := req.Validate(definition); err != nil {
-		return nil, err
-	}
-
 	// can only update config for a connected cloud account id
 	_, apiErr := c.accountsRepo.getConnectedCloudAccount(
 		ctx, orgID, cloudProvider, req.CloudAccountId,
@@ -505,15 +489,21 @@ func (c *Controller) UpdateServiceConfig(
 		return nil, model.WrapApiError(apiErr, "couldn't find connected cloud account")
 	}
 
+	// can only update config for a valid service.
+	_, apiErr = getCloudProviderService(cloudProvider, serviceId)
+	if apiErr != nil {
+		return nil, model.WrapApiError(apiErr, "unsupported service")
+	}
+
 	updatedConfig, apiErr := c.serviceConfigRepo.upsert(
-		ctx, orgID, cloudProvider, req.CloudAccountId, serviceType, req.Config,
+		ctx, orgID, cloudProvider, req.CloudAccountId, serviceId, req.Config,
 	)
 	if apiErr != nil {
 		return nil, model.WrapApiError(apiErr, "couldn't update service config")
 	}
 
 	return &UpdateServiceConfigResponse{
-		Id:     serviceType,
+		Id:     serviceId,
 		Config: *updatedConfig,
 	}, nil
 }
@@ -568,7 +558,7 @@ func (c *Controller) AvailableDashboardsForCloudProvider(
 		}
 	}
 
-	allServices, apiErr := services.List(cloudProvider)
+	allServices, apiErr := listCloudProviderServices(cloudProvider)
 	if apiErr != nil {
 		return nil, apiErr
 	}

pkg/query-service/app/cloudintegrations/controller_test.go

@@ -76,26 +76,26 @@ func TestAgentCheckIns(t *testing.T) {
 	// if no connection url was requested (no account with agent's account id exists)
 	testAccountId1 := uuid.NewString()
 	testCloudAccountId1 := "546311234"
-	resp1, err := controller.CheckInAsAgent(
+	resp1, apiErr := controller.CheckInAsAgent(
 		context.TODO(), user.OrgID, "aws", AgentCheckInRequest{
 			ID:        testAccountId1,
 			AccountID: testCloudAccountId1,
 		},
 	)
-	require.Nil(err)
+	require.Nil(apiErr)
 	require.Equal(testAccountId1, resp1.AccountId)
 	require.Equal(testCloudAccountId1, resp1.CloudAccountId)
 
 	// The agent should not be able to check in with a different
 	// cloud account id for the same account.
 	testCloudAccountId2 := "99999999"
-	_, err = controller.CheckInAsAgent(
+	_, apiErr = controller.CheckInAsAgent(
 		context.TODO(), user.OrgID, "aws", AgentCheckInRequest{
 			ID:        testAccountId1,
 			AccountID: testCloudAccountId2,
 		},
 	)
-	require.NotNil(err)
+	require.NotNil(apiErr)
 
 	// The agent should not be able to check-in with a particular cloud account id
 	// if another connected AccountRecord exists for same cloud account
@@ -110,13 +110,13 @@ func TestAgentCheckIns(t *testing.T) {
 	require.Nil(existingConnected.RemovedAt)
 
 	testAccountId2 := uuid.NewString()
-	_, err = controller.CheckInAsAgent(
+	_, apiErr = controller.CheckInAsAgent(
 		context.TODO(), user.OrgID, "aws", AgentCheckInRequest{
 			ID:        testAccountId2,
 			AccountID: testCloudAccountId1,
 		},
 	)
-	require.NotNil(err)
+	require.NotNil(apiErr)
 
 	// After disconnecting existing account record, the agent should be able to
 	// connected for a particular cloud account id
@@ -131,22 +131,22 @@ func TestAgentCheckIns(t *testing.T) {
 	require.NotNil(apiErr)
 	require.Equal(model.ErrorNotFound, apiErr.Type())
 
-	_, err = controller.CheckInAsAgent(
+	_, apiErr = controller.CheckInAsAgent(
 		context.TODO(), user.OrgID, "aws", AgentCheckInRequest{
 			ID:        testAccountId2,
 			AccountID: testCloudAccountId1,
 		},
 	)
-	require.Nil(err)
+	require.Nil(apiErr)
 
 	// should be able to keep checking in
-	_, err = controller.CheckInAsAgent(
+	_, apiErr = controller.CheckInAsAgent(
 		context.TODO(), user.OrgID, "aws", AgentCheckInRequest{
 			ID:        testAccountId2,
 			AccountID: testCloudAccountId1,
 		},
 	)
-	require.Nil(err)
+	require.Nil(apiErr)
 }
 
 func TestCantDisconnectNonExistentAccount(t *testing.T) {
@@ -194,10 +194,10 @@ func TestConfigureService(t *testing.T) {
 	testSvcId := svcListResp.Services[0].Id
 	require.Nil(svcListResp.Services[0].Config)
 
-	svcDetails, err := controller.GetServiceDetails(
+	svcDetails, apiErr := controller.GetServiceDetails(
 		context.TODO(), user.OrgID, "aws", testSvcId, &testCloudAccountId,
 	)
-	require.Nil(err)
+	require.Nil(apiErr)
 	require.Equal(testSvcId, svcDetails.Id)
 	require.Nil(svcDetails.Config)
 
@@ -207,20 +207,20 @@ func TestConfigureService(t *testing.T) {
 			Enabled: true,
 		},
 	}
-	updateSvcConfigResp, err := controller.UpdateServiceConfig(
-		context.TODO(), user.OrgID, "aws", testSvcId, &UpdateServiceConfigRequest{
+	updateSvcConfigResp, apiErr := controller.UpdateServiceConfig(
+		context.TODO(), user.OrgID, "aws", testSvcId, UpdateServiceConfigRequest{
 			CloudAccountId: testCloudAccountId,
 			Config:         testSvcConfig,
 		},
 	)
-	require.Nil(err)
+	require.Nil(apiErr)
 	require.Equal(testSvcId, updateSvcConfigResp.Id)
 	require.Equal(testSvcConfig, updateSvcConfigResp.Config)
 
-	svcDetails, err = controller.GetServiceDetails(
+	svcDetails, apiErr = controller.GetServiceDetails(
 		context.TODO(), user.OrgID, "aws", testSvcId, &testCloudAccountId,
 	)
-	require.Nil(err)
+	require.Nil(apiErr)
 	require.Equal(testSvcId, svcDetails.Id)
 	require.Equal(testSvcConfig, *svcDetails.Config)
 
@@ -240,33 +240,33 @@ func TestConfigureService(t *testing.T) {
 	)
 	require.Nil(apiErr)
 
-	_, err = controller.UpdateServiceConfig(
+	_, apiErr = controller.UpdateServiceConfig(
 		context.TODO(), user.OrgID, "aws", testSvcId,
-		&UpdateServiceConfigRequest{
+		UpdateServiceConfigRequest{
 			CloudAccountId: testCloudAccountId,
 			Config:         testSvcConfig,
 		},
 	)
-	require.NotNil(err)
+	require.NotNil(apiErr)
 
 	// should not be able to configure a service for a cloud account id that is not connected yet
-	_, err = controller.UpdateServiceConfig(
+	_, apiErr = controller.UpdateServiceConfig(
 		context.TODO(), user.OrgID, "aws", testSvcId,
-		&UpdateServiceConfigRequest{
+		UpdateServiceConfigRequest{
 			CloudAccountId: "9999999999",
 			Config:         testSvcConfig,
 		},
 	)
-	require.NotNil(err)
+	require.NotNil(apiErr)
 
 	// should not be able to set config for an unsupported service
-	_, err = controller.UpdateServiceConfig(
-		context.TODO(), user.OrgID, "aws", "bad-service", &UpdateServiceConfigRequest{
+	_, apiErr = controller.UpdateServiceConfig(
+		context.TODO(), user.OrgID, "aws", "bad-service", UpdateServiceConfigRequest{
 			CloudAccountId: testCloudAccountId,
 			Config:         testSvcConfig,
 		},
 	)
-	require.NotNil(err)
+	require.NotNil(apiErr)
 
 }
 

pkg/query-service/app/cloudintegrations/model.go

@@ -0,0 +1,183 @@
+package cloudintegrations
+
+import (
+	"fmt"
+
+	"github.com/SigNoz/signoz/pkg/types"
+)
+
+type CloudServiceSummary struct {
+	Id    string `json:"id"`
+	Title string `json:"title"`
+	Icon  string `json:"icon"`
+
+	// Present only if the service has been configured in the
+	// context of a cloud provider account.
+	Config *types.CloudServiceConfig `json:"config,omitempty"`
+}
+
+type CloudServiceDetails struct {
+	CloudServiceSummary
+
+	Overview string `json:"overview"` // markdown
+
+	Assets CloudServiceAssets `json:"assets"`
+
+	SupportedSignals SupportedSignals `json:"supported_signals"`
+
+	DataCollected DataCollectedForService `json:"data_collected"`
+
+	ConnectionStatus *CloudServiceConnectionStatus `json:"status,omitempty"`
+
+	TelemetryCollectionStrategy *CloudTelemetryCollectionStrategy `json:"telemetry_collection_strategy"`
+}
+
+type CloudServiceAssets struct {
+	Dashboards []CloudServiceDashboard `json:"dashboards"`
+}
+
+type CloudServiceDashboard struct {
+	Id          string               `json:"id"`
+	Url         string               `json:"url"`
+	Title       string               `json:"title"`
+	Description string               `json:"description"`
+	Image       string               `json:"image"`
+	Definition  *types.DashboardData `json:"definition,omitempty"`
+}
+
+type SupportedSignals struct {
+	Logs    bool `json:"logs"`
+	Metrics bool `json:"metrics"`
+}
+
+type DataCollectedForService struct {
+	Logs    []CollectedLogAttribute `json:"logs"`
+	Metrics []CollectedMetric       `json:"metrics"`
+}
+
+type CollectedLogAttribute struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+	Type string `json:"type"`
+}
+
+type CollectedMetric struct {
+	Name        string `json:"name"`
+	Type        string `json:"type"`
+	Unit        string `json:"unit"`
+	Description string `json:"description"`
+}
+
+type CloudServiceConnectionStatus struct {
+	Logs    *SignalConnectionStatus `json:"logs"`
+	Metrics *SignalConnectionStatus `json:"metrics"`
+}
+
+type SignalConnectionStatus struct {
+	LastReceivedTsMillis int64  `json:"last_received_ts_ms"` // epoch milliseconds
+	LastReceivedFrom     string `json:"last_received_from"`  // resource identifier
+}
+
+type CloudTelemetryCollectionStrategy struct {
+	Provider string `json:"provider"`
+
+	AWSMetrics *AWSMetricsCollectionStrategy `json:"aws_metrics,omitempty"`
+	AWSLogs    *AWSLogsCollectionStrategy    `json:"aws_logs,omitempty"`
+}
+
+func NewCloudTelemetryCollectionStrategy(provider string) (*CloudTelemetryCollectionStrategy, error) {
+	if provider == "aws" {
+		return &CloudTelemetryCollectionStrategy{
+			Provider: "aws",
+			AWSMetrics: &AWSMetricsCollectionStrategy{
+				CloudwatchMetricsStreamFilters: []CloudwatchMetricStreamFilter{},
+			},
+			AWSLogs: &AWSLogsCollectionStrategy{
+				CloudwatchLogsSubscriptions: []CloudwatchLogsSubscriptionConfig{},
+			},
+		}, nil
+	}
+
+	return nil, fmt.Errorf("unsupported cloud provider: %s", provider)
+}
+
+// Helper for accumulating strategies for enabled services.
+func (cs *CloudTelemetryCollectionStrategy) AddServiceStrategy(
+	svcStrategy *CloudTelemetryCollectionStrategy,
+	logsEnabled bool,
+	metricsEnabled bool,
+) error {
+	if svcStrategy.Provider != cs.Provider {
+		return fmt.Errorf(
+			"can't add %s service strategy to strategy for %s",
+			svcStrategy.Provider, cs.Provider,
+		)
+	}
+
+	if cs.Provider == "aws" {
+		if logsEnabled {
+			cs.AWSLogs.AddServiceStrategy(svcStrategy.AWSLogs)
+		}
+		if metricsEnabled {
+			cs.AWSMetrics.AddServiceStrategy(svcStrategy.AWSMetrics)
+		}
+		return nil
+	}
+
+	return fmt.Errorf("unsupported cloud provider: %s", cs.Provider)
+
+}
+
+type AWSMetricsCollectionStrategy struct {
+	// to be used as https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudwatch-metricstream.html#cfn-cloudwatch-metricstream-includefilters
+	CloudwatchMetricsStreamFilters []CloudwatchMetricStreamFilter `json:"cloudwatch_metric_stream_filters"`
+}
+
+type CloudwatchMetricStreamFilter struct {
+	// json tags here are in the shape expected by AWS API as detailed at
+	// https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cloudwatch-metricstream-metricstreamfilter.html
+	Namespace   string   `json:"Namespace"`
+	MetricNames []string `json:"MetricNames,omitempty"`
+}
+
+func (amc *AWSMetricsCollectionStrategy) AddServiceStrategy(
+	svcStrategy *AWSMetricsCollectionStrategy,
+) error {
+	if svcStrategy == nil {
+		return nil
+	}
+
+	amc.CloudwatchMetricsStreamFilters = append(
+		amc.CloudwatchMetricsStreamFilters,
+		svcStrategy.CloudwatchMetricsStreamFilters...,
+	)
+	return nil
+}
+
+type AWSLogsCollectionStrategy struct {
+	CloudwatchLogsSubscriptions []CloudwatchLogsSubscriptionConfig `json:"cloudwatch_logs_subscriptions"`
+}
+
+type CloudwatchLogsSubscriptionConfig struct {
+	// subscribe to all logs groups with specified prefix.
+	// eg: `/aws/rds/`
+	LogGroupNamePrefix string `json:"log_group_name_prefix"`
+
+	// https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html
+	// "" implies no filtering is required.
+	FilterPattern string `json:"filter_pattern"`
+}
+
+func (alc *AWSLogsCollectionStrategy) AddServiceStrategy(
+	svcStrategy *AWSLogsCollectionStrategy,
+) error {
+	if svcStrategy == nil {
+		return nil
+	}
+
+	alc.CloudwatchLogsSubscriptions = append(
+		alc.CloudwatchLogsSubscriptions,
+		svcStrategy.CloudwatchLogsSubscriptions...,
+	)
+	return nil
+}

pkg/query-service/app/cloudintegrations/models.go

@@ -1,94 +0,0 @@
-package cloudintegrations
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
-	"github.com/SigNoz/signoz/pkg/types"
-)
-
-type ServiceSummary struct {
-	services.Metadata
-
-	Config *types.CloudServiceConfig `json:"config"`
-}
-
-type ServiceDetails struct {
-	services.Definition
-
-	Config           *types.CloudServiceConfig `json:"config"`
-	ConnectionStatus *ServiceConnectionStatus  `json:"status,omitempty"`
-}
-
-type AccountStatus struct {
-	Integration AccountIntegrationStatus `json:"integration"`
-}
-
-type AccountIntegrationStatus struct {
-	LastHeartbeatTsMillis *int64 `json:"last_heartbeat_ts_ms"`
-}
-
-type LogsConfig struct {
-	Enabled   bool                `json:"enabled"`
-	S3Buckets map[string][]string `json:"s3_buckets,omitempty"`
-}
-
-type MetricsConfig struct {
-	Enabled bool `json:"enabled"`
-}
-
-type ServiceConnectionStatus struct {
-	Logs    *SignalConnectionStatus `json:"logs"`
-	Metrics *SignalConnectionStatus `json:"metrics"`
-}
-
-type SignalConnectionStatus struct {
-	LastReceivedTsMillis int64  `json:"last_received_ts_ms"` // epoch milliseconds
-	LastReceivedFrom     string `json:"last_received_from"`  // resource identifier
-}
-
-type CompiledCollectionStrategy = services.CollectionStrategy
-
-func NewCompiledCollectionStrategy(provider string) (*CompiledCollectionStrategy, error) {
-	if provider == "aws" {
-		return &CompiledCollectionStrategy{
-			Provider:   "aws",
-			AWSMetrics: &services.AWSMetricsStrategy{},
-			AWSLogs:    &services.AWSLogsStrategy{},
-		}, nil
-	}
-	return nil, errors.NewNotFoundf(services.CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", provider)
-}
-
-// Helper for accumulating strategies for enabled services.
-func AddServiceStrategy(serviceType string, cs *CompiledCollectionStrategy,
-	definitionStrat *services.CollectionStrategy, config *types.CloudServiceConfig) error {
-	if definitionStrat.Provider != cs.Provider {
-		return errors.NewInternalf(CodeMismatchCloudProvider, "can't add %s service strategy to compiled strategy for %s",
-			definitionStrat.Provider, cs.Provider)
-	}
-
-	if cs.Provider == "aws" {
-		if config.Logs != nil && config.Logs.Enabled {
-			if serviceType == services.S3Sync {
-				// S3 bucket sync; No cloudwatch logs are appended for this service type;
-				// Though definition is populated with a custom cloudwatch group that helps in calculating logs connection status
-				cs.S3Buckets = config.Logs.S3Buckets
-			} else if definitionStrat.AWSLogs != nil { // services that includes a logs subscription
-				cs.AWSLogs.Subscriptions = append(
-					cs.AWSLogs.Subscriptions,
-					definitionStrat.AWSLogs.Subscriptions...,
-				)
-			}
-		}
-		if config.Metrics != nil && config.Metrics.Enabled && definitionStrat.AWSMetrics != nil {
-			cs.AWSMetrics.StreamFilters = append(
-				cs.AWSMetrics.StreamFilters,
-				definitionStrat.AWSMetrics.StreamFilters...,
-			)
-		}
-
-		return nil
-	}
-
-	return errors.NewNotFoundf(services.CodeUnsupportedCloudProvider, "unsupported cloud provider: %s", cs.Provider)
-}

pkg/query-service/app/cloudintegrations/serviceConfigRepo.go

@@ -12,7 +12,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-type ServiceConfigDatabase interface {
+type serviceConfigRepository interface {
 	get(
 		ctx context.Context,
 		orgID string,
@@ -140,6 +140,7 @@ func (r *serviceConfigSQLRepository) getAllForAccount(
 	orgID string,
 	cloudAccountId string,
 ) (map[string]*types.CloudServiceConfig, *model.ApiError) {
+
 	serviceConfigs := []types.CloudIntegrationService{}
 
 	err := r.store.BunDB().NewSelect().

pkg/query-service/app/cloudintegrations/services/definitions/aws/s3sync/icon.svg

@@ -1 +0,0 @@
-<svg width="256" height="256" viewBox="0 0 256 256" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid"><title>AWS Simple Storage Service (S3)</title><defs><linearGradient x1="0%" y1="100%" x2="100%" y2="0%" id="a"><stop stop-color="#1B660F" offset="0%"/><stop stop-color="#6CAE3E" offset="100%"/></linearGradient></defs><g><rect fill="url(#a)" width="256" height="256"/><path d="M194.67488,137.25632 L195.90368,128.60352 C207.23488,135.39072 207.38208,138.19392 207.378964,138.27072 C207.35968,138.28672 205.42688,139.89952 194.67488,137.25632 L194.67488,137.25632 Z M188.45728,135.52832 C168.87328,129.60192 141.59968,117.08992 130.56288,111.87392 C130.56288,111.82912 130.57568,111.78752 130.57568,111.74272 C130.57568,107.50272 127.12608,104.05312 122.88288,104.05312 C118.64608,104.05312 115.19648,107.50272 115.19648,111.74272 C115.19648,115.98272 118.64608,119.43232 122.88288,119.43232 C124.74528,119.43232 126.43488,118.73792 127.76928,117.63392 C140.75488,123.78112 167.81728,136.11072 187.54528,141.93472 L179.74368,196.99392 C179.72128,197.14432 179.71168,197.29472 179.71168,197.44512 C179.71168,202.29312 158.24928,211.19872 123.18048,211.19872 C87.74048,211.19872 66.05088,202.29312 66.05088,197.44512 C66.05088,197.29792 66.04128,197.15392 66.02208,197.00992 L49.72128,77.94752 C63.83008,87.65952 94.17568,92.79872 123.19968,92.79872 C152.17888,92.79872 182.47328,87.67872 196.61088,77.99552 L188.45728,135.52832 Z M47.99968,65.52832 C48.23008,61.31712 72.42848,44.79872 123.19968,44.79872 C173.96448,44.79872 198.16608,61.31392 198.39968,65.52832 L198.39968,66.96512 C195.61568,76.40832 164.25568,86.39872 123.19968,86.39872 C82.07328,86.39872 50.69728,76.37632 47.99968,66.92032 L47.99968,65.52832 Z M204.79968,65.59872 C204.79968,54.51072 173.01088,38.39872 123.19968,38.39872 C73.38848,38.39872 41.59968,54.51072 41.59968,65.59872 L41.90048,68.01152 L59.65408,197.68832 C60.07968,212.19072 98.75488,217.59872 123.18048,217.59872 C153.49088,217.59872 185.69248,210.62912 186.10848,197.69792 L193.77568,143.62752 C198.04128,144.64832 201.55168,145.16992 204.37088,145.16992 C208.15648,145.16992 210.71648,144.24512 212.26848,142.39552 C213.54208,140.87872 214.02848,139.04192 213.66368,137.08672 C212.83488,132.65792 207.57728,127.88352 196.87008,121.77472 L204.47328,68.13632 L204.79968,65.59872 Z" fill="#FFFFFF"/></g></svg>

pkg/query-service/app/cloudintegrations/services/definitions/aws/s3sync/integration.json

@@ -1,52 +0,0 @@
-{
-  "id": "s3sync",
-  "title": "S3 Sync",
-  "icon": "file://icon.svg",
-  "overview": "file://overview.md",
-  "supported_signals": {
-    "metrics": false,
-    "logs": true
-  },
-  "data_collected": {
-    "logs": [
-      {
-        "name": "Account ID",
-        "path": "resources.cloud.account.id",
-        "type": "string"
-      },
-      {
-        "name": "Account Region",
-        "path": "resources.cloud.account.region",
-        "type": "string"
-      },
-      {
-        "name": "Bucket Name",
-        "path": "resources.cloud.bucket.name",
-        "type": "string"
-      },
-      {
-        "name": "Object Key",
-        "path": "attributes.object.key",
-        "type": "string"
-      },
-      {
-        "name": "Object S3 Event Time",
-        "path": "attributes.object.event_time",
-        "type": "string"
-      }
-    ]
-  },
-  "telemetry_collection_strategy": {
-    "aws_logs": {
-      "cloudwatch_logs_subscriptions": [
-        {
-          "log_group_name_prefix": "x/signoz/forwarder",
-          "filter_pattern": ""
-        }
-      ]
-    }
-  },
-  "assets": {
-    "dashboards": []
-  }
-}

pkg/query-service/app/cloudintegrations/services/definitions/aws/s3sync/overview.md

@@ -1,3 +0,0 @@
-### Sync logs stored in S3 Object Store with SigNoz
-
-Collect logs stored by AWS Services in S3 Object Store and explore them in SigNoz.

pkg/query-service/app/cloudintegrations/services/models.go

@@ -1,91 +0,0 @@
-package services
-
-import (
-	"github.com/SigNoz/signoz/pkg/types"
-)
-
-type Metadata struct {
-	Id    string `json:"id"`
-	Title string `json:"title"`
-	Icon  string `json:"icon"`
-}
-
-type Definition struct {
-	Metadata
-
-	Overview string `json:"overview"` // markdown
-
-	Assets Assets `json:"assets"`
-
-	SupportedSignals SupportedSignals `json:"supported_signals"`
-
-	DataCollected DataCollected `json:"data_collected"`
-
-	Strategy *CollectionStrategy `json:"telemetry_collection_strategy"`
-}
-
-type Assets struct {
-	Dashboards []Dashboard `json:"dashboards"`
-}
-
-type SupportedSignals struct {
-	Logs    bool `json:"logs"`
-	Metrics bool `json:"metrics"`
-}
-
-type DataCollected struct {
-	Logs    []CollectedLogAttribute `json:"logs"`
-	Metrics []CollectedMetric       `json:"metrics"`
-}
-
-type CollectedLogAttribute struct {
-	Name string `json:"name"`
-	Path string `json:"path"`
-	Type string `json:"type"`
-}
-
-type CollectedMetric struct {
-	Name        string `json:"name"`
-	Type        string `json:"type"`
-	Unit        string `json:"unit"`
-	Description string `json:"description"`
-}
-
-type CollectionStrategy struct {
-	Provider string `json:"provider"`
-
-	AWSMetrics *AWSMetricsStrategy `json:"aws_metrics,omitempty"`
-	AWSLogs    *AWSLogsStrategy    `json:"aws_logs,omitempty"`
-	S3Buckets  map[string][]string `json:"s3_buckets,omitempty"` // Only available in S3 Sync Service Type
-}
-
-type AWSMetricsStrategy struct {
-	// to be used as https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudwatch-metricstream.html#cfn-cloudwatch-metricstream-includefilters
-	StreamFilters []struct {
-		// json tags here are in the shape expected by AWS API as detailed at
-		// https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cloudwatch-metricstream-metricstreamfilter.html
-		Namespace   string   `json:"Namespace"`
-		MetricNames []string `json:"MetricNames,omitempty"`
-	} `json:"cloudwatch_metric_stream_filters"`
-}
-
-type AWSLogsStrategy struct {
-	Subscriptions []struct {
-		// subscribe to all logs groups with specified prefix.
-		// eg: `/aws/rds/`
-		LogGroupNamePrefix string `json:"log_group_name_prefix"`
-
-		// https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html
-		// "" implies no filtering is required.
-		FilterPattern string `json:"filter_pattern"`
-	} `json:"cloudwatch_logs_subscriptions"`
-}
-
-type Dashboard struct {
-	Id          string               `json:"id"`
-	Url         string               `json:"url"`
-	Title       string               `json:"title"`
-	Description string               `json:"description"`
-	Image       string               `json:"image"`
-	Definition  *types.DashboardData `json:"definition,omitempty"`
-}

pkg/query-service/app/http_handler.go

@@ -24,10 +24,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
-	"github.com/SigNoz/signoz/pkg/query-service/app/cloudintegrations/services"
+	tracefunnels "github.com/SigNoz/signoz/pkg/modules/tracefunnel"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/signoz"
+	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunnel"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/prometheus/promql"
 
@@ -1712,7 +1713,7 @@ func (aH *APIHandler) getServices(w http.ResponseWriter, r *http.Request) {
 		"number": len(*result),
 	}
 	claims, errv2 := authtypes.ClaimsFromContext(r.Context())
-	if errv2 == nil {
+	if errv2 != nil {
 		telemetry.GetInstance().SendEvent(telemetry.TELEMETRY_EVENT_NUMBER_OF_SERVICES, data, claims.Email, true, false)
 	}
 
@@ -3986,12 +3987,12 @@ func (aH *APIHandler) CloudIntegrationsAgentCheckIn(
 		return
 	}
 
-	result, err := aH.CloudIntegrationsController.CheckInAsAgent(
+	result, apiErr := aH.CloudIntegrationsController.CheckInAsAgent(
 		r.Context(), claims.OrgID, cloudProvider, req,
 	)
 
-	if err != nil {
-		render.Error(w, err)
+	if apiErr != nil {
+		RespondError(w, apiErr, nil)
 		return
 	}
 
@@ -4111,11 +4112,11 @@ func (aH *APIHandler) CloudIntegrationsGetServiceDetails(
 		return
 	}
 
-	resp, err := aH.CloudIntegrationsController.GetServiceDetails(
+	resp, apiErr := aH.CloudIntegrationsController.GetServiceDetails(
 		r.Context(), claims.OrgID, cloudProvider, serviceId, cloudAccountId,
 	)
-	if err != nil {
-		render.Error(w, err)
+	if apiErr != nil {
+		RespondError(w, apiErr, nil)
 		return
 	}
 
@@ -4139,8 +4140,8 @@ func (aH *APIHandler) calculateCloudIntegrationServiceConnectionStatus(
 	orgID valuer.UUID,
 	cloudProvider string,
 	cloudAccountId string,
-	svcDetails *cloudintegrations.ServiceDetails,
-) (*cloudintegrations.ServiceConnectionStatus, *model.ApiError) {
+	svcDetails *cloudintegrations.CloudServiceDetails,
+) (*cloudintegrations.CloudServiceConnectionStatus, *model.ApiError) {
 	if cloudProvider != "aws" {
 		// TODO(Raj): Make connection check generic for all providers in a follow up change
 		return nil, model.BadRequest(
@@ -4148,14 +4149,14 @@ func (aH *APIHandler) calculateCloudIntegrationServiceConnectionStatus(
 		)
 	}
 
-	telemetryCollectionStrategy := svcDetails.Strategy
+	telemetryCollectionStrategy := svcDetails.TelemetryCollectionStrategy
 	if telemetryCollectionStrategy == nil {
 		return nil, model.InternalError(fmt.Errorf(
 			"service doesn't have telemetry collection strategy: %s", svcDetails.Id,
 		))
 	}
 
-	result := &cloudintegrations.ServiceConnectionStatus{}
+	result := &cloudintegrations.CloudServiceConnectionStatus{}
 	errors := []*model.ApiError{}
 	var resultLock sync.Mutex
 
@@ -4215,10 +4216,10 @@ func (aH *APIHandler) calculateCloudIntegrationServiceConnectionStatus(
 func (aH *APIHandler) calculateAWSIntegrationSvcMetricsConnectionStatus(
 	ctx context.Context,
 	cloudAccountId string,
-	strategy *services.AWSMetricsStrategy,
-	metricsCollectedBySvc []services.CollectedMetric,
+	strategy *cloudintegrations.AWSMetricsCollectionStrategy,
+	metricsCollectedBySvc []cloudintegrations.CollectedMetric,
 ) (*cloudintegrations.SignalConnectionStatus, *model.ApiError) {
-	if strategy == nil || len(strategy.StreamFilters) < 1 {
+	if strategy == nil || len(strategy.CloudwatchMetricsStreamFilters) < 1 {
 		return nil, nil
 	}
 
@@ -4227,7 +4228,7 @@ func (aH *APIHandler) calculateAWSIntegrationSvcMetricsConnectionStatus(
 		"cloud_account_id": cloudAccountId,
 	}
 
-	metricsNamespace := strategy.StreamFilters[0].Namespace
+	metricsNamespace := strategy.CloudwatchMetricsStreamFilters[0].Namespace
 	metricsNamespaceParts := strings.Split(metricsNamespace, "/")
 
 	if len(metricsNamespaceParts) >= 2 {
@@ -4265,13 +4266,13 @@ func (aH *APIHandler) calculateAWSIntegrationSvcLogsConnectionStatus(
 	ctx context.Context,
 	orgID valuer.UUID,
 	cloudAccountId string,
-	strategy *services.AWSLogsStrategy,
+	strategy *cloudintegrations.AWSLogsCollectionStrategy,
 ) (*cloudintegrations.SignalConnectionStatus, *model.ApiError) {
-	if strategy == nil || len(strategy.Subscriptions) < 1 {
+	if strategy == nil || len(strategy.CloudwatchLogsSubscriptions) < 1 {
 		return nil, nil
 	}
 
-	logGroupNamePrefix := strategy.Subscriptions[0].LogGroupNamePrefix
+	logGroupNamePrefix := strategy.CloudwatchLogsSubscriptions[0].LogGroupNamePrefix
 	if len(logGroupNamePrefix) < 1 {
 		return nil, nil
 	}
@@ -4359,12 +4360,12 @@ func (aH *APIHandler) CloudIntegrationsUpdateServiceConfig(
 		return
 	}
 
-	result, err := aH.CloudIntegrationsController.UpdateServiceConfig(
-		r.Context(), claims.OrgID, cloudProvider, serviceId, &req,
+	result, apiErr := aH.CloudIntegrationsController.UpdateServiceConfig(
+		r.Context(), claims.OrgID, cloudProvider, serviceId, req,
 	)
 
-	if err != nil {
-		render.Error(w, err)
+	if apiErr != nil {
+		RespondError(w, apiErr, nil)
 		return
 	}
 
@@ -5664,3 +5665,226 @@ func (aH *APIHandler) getDomainInfo(w http.ResponseWriter, r *http.Request) {
 	}
 	aH.Respond(w, resp)
 }
+
+// RegisterTraceFunnelsRoutes adds trace funnels routes
+func (aH *APIHandler) RegisterTraceFunnelsRoutes(router *mux.Router, am *middleware.AuthZ) {
+	// Main trace funnels router
+	traceFunnelsRouter := router.PathPrefix("/api/v1/trace-funnels").Subrouter()
+
+	// API endpoints
+	traceFunnelsRouter.HandleFunc("/new",
+		am.ViewAccess(aH.Signoz.Handlers.TraceFunnel.New)).
+		Methods(http.MethodPost)
+	traceFunnelsRouter.HandleFunc("/list",
+		am.ViewAccess(aH.Signoz.Handlers.TraceFunnel.List)).
+		Methods(http.MethodGet)
+	traceFunnelsRouter.HandleFunc("/steps/update",
+		am.ViewAccess(aH.Signoz.Handlers.TraceFunnel.UpdateSteps)).
+		Methods(http.MethodPut)
+
+	traceFunnelsRouter.HandleFunc("/{funnel_id}",
+		am.ViewAccess(aH.Signoz.Handlers.TraceFunnel.Get)).
+		Methods(http.MethodGet)
+	traceFunnelsRouter.HandleFunc("/{funnel_id}",
+		am.ViewAccess(aH.Signoz.Handlers.TraceFunnel.Delete)).
+		Methods(http.MethodDelete)
+	traceFunnelsRouter.HandleFunc("/{funnel_id}",
+		am.ViewAccess(aH.Signoz.Handlers.TraceFunnel.UpdateFunnel)).
+		Methods(http.MethodPut)
+	traceFunnelsRouter.HandleFunc("/save",
+		am.ViewAccess(aH.Signoz.Handlers.TraceFunnel.Save)).
+		Methods(http.MethodPost)
+	// Analytics endpoints
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/validate", aH.handleValidateTraces).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/overview", aH.handleFunnelAnalytics).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/steps", aH.handleStepAnalytics).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/steps/overview", aH.handleFunnelStepAnalytics).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/slow-traces", aH.handleFunnelSlowTraces).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/error-traces", aH.handleFunnelErrorTraces).Methods("POST")
+
+}
+
+func (aH *APIHandler) handleValidateTraces(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := aH.Signoz.Modules.TraceFunnel.Get(r.Context(), funnelID)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("funnel not found: %v", err)}, nil)
+		return
+	}
+
+	var timeRange traceFunnels.TimeRange
+	if err := json.NewDecoder(r.Body).Decode(&timeRange); err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("error decoding time range: %v", err)}, nil)
+		return
+	}
+
+	if len(funnel.Steps) < 2 {
+		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("funnel must have at least 2 steps")}, nil)
+		return
+	}
+
+	chq, err := tracefunnels.ValidateTraces(funnel, timeRange)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error building clickhouse query: %v", err)}, nil)
+		return
+	}
+
+	results, err := aH.reader.GetListResultV3(r.Context(), chq.Query)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error converting clickhouse results to list: %v", err)}, nil)
+		return
+	}
+	aH.Respond(w, results)
+}
+
+func (aH *APIHandler) handleFunnelAnalytics(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := aH.Signoz.Modules.TraceFunnel.Get(r.Context(), funnelID)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("funnel not found: %v", err)}, nil)
+		return
+	}
+
+	var stepTransition traceFunnels.StepTransitionRequest
+	if err := json.NewDecoder(r.Body).Decode(&stepTransition); err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("error decoding time range: %v", err)}, nil)
+		return
+	}
+
+	chq, err := tracefunnels.GetFunnelAnalytics(funnel, stepTransition.TimeRange)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error building clickhouse query: %v", err)}, nil)
+		return
+	}
+
+	results, err := aH.reader.GetListResultV3(r.Context(), chq.Query)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error converting clickhouse results to list: %v", err)}, nil)
+		return
+	}
+	aH.Respond(w, results)
+}
+
+func (aH *APIHandler) handleFunnelStepAnalytics(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := aH.Signoz.Modules.TraceFunnel.Get(r.Context(), funnelID)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("funnel not found: %v", err)}, nil)
+		return
+	}
+
+	var stepTransition traceFunnels.StepTransitionRequest
+	if err := json.NewDecoder(r.Body).Decode(&stepTransition); err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("error decoding time range: %v", err)}, nil)
+		return
+	}
+
+	chq, err := tracefunnels.GetFunnelStepAnalytics(funnel, stepTransition.TimeRange, stepTransition.StepAOrder, stepTransition.StepBOrder)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error building clickhouse query: %v", err)}, nil)
+		return
+	}
+
+	results, err := aH.reader.GetListResultV3(r.Context(), chq.Query)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error converting clickhouse results to list: %v", err)}, nil)
+		return
+	}
+	aH.Respond(w, results)
+}
+
+func (aH *APIHandler) handleStepAnalytics(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := aH.Signoz.Modules.TraceFunnel.Get(r.Context(), funnelID)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("funnel not found: %v", err)}, nil)
+		return
+	}
+
+	var timeRange traceFunnels.TimeRange
+	if err := json.NewDecoder(r.Body).Decode(&timeRange); err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("error decoding time range: %v", err)}, nil)
+		return
+	}
+
+	chq, err := tracefunnels.GetStepAnalytics(funnel, timeRange)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error building clickhouse query: %v", err)}, nil)
+		return
+	}
+
+	results, err := aH.reader.GetListResultV3(r.Context(), chq.Query)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error converting clickhouse results to list: %v", err)}, nil)
+		return
+	}
+	aH.Respond(w, results)
+}
+
+func (aH *APIHandler) handleFunnelSlowTraces(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := aH.Signoz.Modules.TraceFunnel.Get(r.Context(), funnelID)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("funnel not found: %v", err)}, nil)
+		return
+	}
+
+	var req traceFunnels.StepTransitionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("invalid request body: %v", err)}, nil)
+		return
+	}
+
+	chq, err := tracefunnels.GetSlowestTraces(funnel, req.TimeRange, req.StepAOrder, req.StepBOrder)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error building clickhouse query: %v", err)}, nil)
+		return
+	}
+
+	results, err := aH.reader.GetListResultV3(r.Context(), chq.Query)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error converting clickhouse results to list: %v", err)}, nil)
+		return
+	}
+	aH.Respond(w, results)
+}
+
+func (aH *APIHandler) handleFunnelErrorTraces(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	funnelID := vars["funnel_id"]
+
+	funnel, err := aH.Signoz.Modules.TraceFunnel.Get(r.Context(), funnelID)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("funnel not found: %v", err)}, nil)
+		return
+	}
+
+	var req traceFunnels.StepTransitionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("invalid request body: %v", err)}, nil)
+		return
+	}
+
+	chq, err := tracefunnels.GetErroredTraces(funnel, req.TimeRange, req.StepAOrder, req.StepBOrder)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error building clickhouse query: %v", err)}, nil)
+		return
+	}
+
+	results, err := aH.reader.GetListResultV3(r.Context(), chq.Query)
+	if err != nil {
+		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: fmt.Errorf("error converting clickhouse results to list: %v", err)}, nil)
+		return
+	}
+	aH.Respond(w, results)
+}

pkg/query-service/app/server.go

@@ -149,8 +149,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	}
 
 	telemetry.GetInstance().SetReader(reader)
-	quickfiltermodule := quickfilterscore.NewQuickFilters(quickfilterscore.NewStore(serverOptions.SigNoz.SQLStore))
-	quickFilter := quickfilter.NewAPI(quickfiltermodule)
+	quickFilterModule := quickfilter.NewAPI(quickfilterscore.NewQuickFilters(quickfilterscore.NewStore(serverOptions.SigNoz.SQLStore)))
 	apiHandler, err := NewAPIHandler(APIHandlerOpts{
 		Reader:                        reader,
 		PreferSpanMetrics:             serverOptions.PreferSpanMetrics,
@@ -165,8 +164,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 		AlertmanagerAPI:               alertmanager.NewAPI(serverOptions.SigNoz.Alertmanager),
 		FieldsAPI:                     fields.NewAPI(serverOptions.SigNoz.TelemetryStore),
 		Signoz:                        serverOptions.SigNoz,
-		QuickFilters:                  quickFilter,
-		QuickFilterModule:             quickfiltermodule,
+		QuickFilters:                  quickFilterModule,
 	})
 	if err != nil {
 		return nil, err
@@ -283,6 +281,7 @@ func (s *Server) createPublicServer(api *APIHandler, web web.Web) (*http.Server,
 	api.RegisterMessagingQueuesRoutes(r, am)
 	api.RegisterThirdPartyApiRoutes(r, am)
 	api.MetricExplorerRoutes(r, am)
+	api.RegisterTraceFunnelsRoutes(r, am)
 
 	c := cors.New(cors.Options{
 		AllowedOrigins: []string{"*"},

pkg/query-service/app/traces/v4/query_builder.go

@@ -87,7 +87,7 @@ func existsSubQueryForFixedColumn(key v3.AttributeKey, op v3.FilterOperator) (st
 	}
 }
 
-func buildTracesFilterQuery(fs *v3.FilterSet) (string, error) {
+func BuildTracesFilterQuery(fs *v3.FilterSet) (string, error) {
 	var conditions []string
 
 	if fs != nil && len(fs.Items) != 0 {
@@ -167,7 +167,7 @@ func handleEmptyValuesInGroupBy(groupBy []v3.AttributeKey) (string, error) {
 			Operator: "AND",
 			Items:    filterItems,
 		}
-		return buildTracesFilterQuery(&filterSet)
+		return BuildTracesFilterQuery(&filterSet)
 	}
 	return "", nil
 }
@@ -248,7 +248,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, panelType v3.
 
 	timeFilter := fmt.Sprintf("(timestamp >= '%d' AND timestamp <= '%d') AND (ts_bucket_start >= %d AND ts_bucket_start <= %d)", tracesStart, tracesEnd, bucketStart, bucketEnd)
 
-	filterSubQuery, err := buildTracesFilterQuery(mq.Filters)
+	filterSubQuery, err := BuildTracesFilterQuery(mq.Filters)
 	if err != nil {
 		return "", err
 	}

pkg/query-service/app/traces/v4/query_builder_test.go

@@ -211,7 +211,7 @@ func Test_buildTracesFilterQuery(t *testing.T) {
 			want: "",
 		},
 		{
-			name: "Test buildTracesFilterQuery in, nin",
+			name: "Test BuildTracesFilterQuery in, nin",
 			args: args{
 				fs: &v3.FilterSet{Operator: "AND", Items: []v3.FilterItem{
 					{Key: v3.AttributeKey{Key: "method", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag}, Value: []interface{}{"GET", "POST"}, Operator: v3.FilterOperatorIn},
@@ -226,7 +226,7 @@ func Test_buildTracesFilterQuery(t *testing.T) {
 			wantErr: false,
 		},
 		{
-			name: "Test buildTracesFilterQuery not eq, neq, gt, lt, gte, lte",
+			name: "Test BuildTracesFilterQuery not eq, neq, gt, lt, gte, lte",
 			args: args{
 				fs: &v3.FilterSet{Operator: "AND", Items: []v3.FilterItem{
 					{Key: v3.AttributeKey{Key: "duration", DataType: v3.AttributeKeyDataTypeInt64, Type: v3.AttributeKeyTypeTag}, Value: 102, Operator: v3.FilterOperatorEqual},
@@ -274,13 +274,13 @@ func Test_buildTracesFilterQuery(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := buildTracesFilterQuery(tt.args.fs)
+			got, err := BuildTracesFilterQuery(tt.args.fs)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("buildTracesFilterQuery() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("BuildTracesFilterQuery() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if got != tt.want {
-				t.Errorf("buildTracesFilterQuery() = %v, want %v", got, tt.want)
+				t.Errorf("BuildTracesFilterQuery() = %v, want %v", got, tt.want)
 			}
 		})
 	}

pkg/query-service/model/featureSet.go

@@ -11,7 +11,6 @@ type Feature struct {
 
 const UseSpanMetrics = "USE_SPAN_METRICS"
 const AnomalyDetection = "ANOMALY_DETECTION"
-const TraceFunnels = "TRACE_FUNNELS"
 
 var BasicPlan = FeatureSet{
 	Feature{
@@ -28,11 +27,4 @@ var BasicPlan = FeatureSet{
 		UsageLimit: -1,
 		Route:      "",
 	},
-	Feature{
-		Name:       TraceFunnels,
-		Active:     false,
-		Usage:      0,
-		UsageLimit: -1,
-		Route:      "",
-	},
 }

pkg/query-service/tests/integration/signoz_cloud_integrations_test.go

@@ -236,9 +236,9 @@ func TestConfigReturnedWhenAgentChecksIn(t *testing.T) {
 	telemetryCollectionStrategy := checkinResp.IntegrationConfig.TelemetryCollectionStrategy
 	require.Equal("aws", telemetryCollectionStrategy.Provider)
 	require.NotNil(telemetryCollectionStrategy.AWSMetrics)
-	require.Empty(telemetryCollectionStrategy.AWSMetrics.StreamFilters)
+	require.Empty(telemetryCollectionStrategy.AWSMetrics.CloudwatchMetricsStreamFilters)
 	require.NotNil(telemetryCollectionStrategy.AWSLogs)
-	require.Empty(telemetryCollectionStrategy.AWSLogs.Subscriptions)
+	require.Empty(telemetryCollectionStrategy.AWSLogs.CloudwatchLogsSubscriptions)
 
 	// helper
 	setServiceConfig := func(svcId string, metricsEnabled bool, logsEnabled bool) {
@@ -283,14 +283,14 @@ func TestConfigReturnedWhenAgentChecksIn(t *testing.T) {
 	require.Equal("aws", telemetryCollectionStrategy.Provider)
 	require.NotNil(telemetryCollectionStrategy.AWSMetrics)
 	metricStreamNamespaces := []string{}
-	for _, f := range telemetryCollectionStrategy.AWSMetrics.StreamFilters {
+	for _, f := range telemetryCollectionStrategy.AWSMetrics.CloudwatchMetricsStreamFilters {
 		metricStreamNamespaces = append(metricStreamNamespaces, f.Namespace)
 	}
 	require.Equal([]string{"AWS/EC2", "CWAgent", "AWS/RDS"}, metricStreamNamespaces)
 
 	require.NotNil(telemetryCollectionStrategy.AWSLogs)
 	logGroupPrefixes := []string{}
-	for _, f := range telemetryCollectionStrategy.AWSLogs.Subscriptions {
+	for _, f := range telemetryCollectionStrategy.AWSLogs.CloudwatchLogsSubscriptions {
 		logGroupPrefixes = append(logGroupPrefixes, f.LogGroupNamePrefix)
 	}
 	require.Equal(1, len(logGroupPrefixes))
@@ -327,14 +327,14 @@ func TestConfigReturnedWhenAgentChecksIn(t *testing.T) {
 	require.Equal("aws", telemetryCollectionStrategy.Provider)
 	require.NotNil(telemetryCollectionStrategy.AWSMetrics)
 	metricStreamNamespaces = []string{}
-	for _, f := range telemetryCollectionStrategy.AWSMetrics.StreamFilters {
+	for _, f := range telemetryCollectionStrategy.AWSMetrics.CloudwatchMetricsStreamFilters {
 		metricStreamNamespaces = append(metricStreamNamespaces, f.Namespace)
 	}
 	require.Equal([]string{"AWS/RDS"}, metricStreamNamespaces)
 
 	require.NotNil(telemetryCollectionStrategy.AWSLogs)
 	logGroupPrefixes = []string{}
-	for _, f := range telemetryCollectionStrategy.AWSLogs.Subscriptions {
+	for _, f := range telemetryCollectionStrategy.AWSLogs.CloudwatchLogsSubscriptions {
 		logGroupPrefixes = append(logGroupPrefixes, f.LogGroupNamePrefix)
 	}
 	require.Equal(0, len(logGroupPrefixes))
@@ -522,7 +522,7 @@ func (tb *CloudIntegrationsTestBed) GetServicesFromQS(
 
 func (tb *CloudIntegrationsTestBed) GetServiceDetailFromQS(
 	cloudProvider string, serviceId string, cloudAccountId *string,
-) *cloudintegrations.ServiceDetails {
+) *cloudintegrations.CloudServiceDetails {
 	path := fmt.Sprintf("/api/v1/cloud-integrations/%s/services/%s", cloudProvider, serviceId)
 	if cloudAccountId != nil {
 		path = fmt.Sprintf("%s?cloud_account_id=%s", path, *cloudAccountId)
@@ -537,7 +537,7 @@ func (tb *CloudIntegrationsTestBed) GetServiceDetailFromQS(
 		`SELECT.*from.*signoz_metrics.*`,
 	).WillReturnRows(mockhouse.NewRows(metricCols, [][]any{}))
 
-	return RequestQSAndParseResp[cloudintegrations.ServiceDetails](
+	return RequestQSAndParseResp[cloudintegrations.CloudServiceDetails](
 		tb, path, nil,
 	)
 }

pkg/signoz/handler.go

@@ -5,16 +5,20 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/preference/implpreference"
+	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/modules/tracefunnel/impltracefunnel"
 )
 
 type Handlers struct {
 	Organization organization.Handler
 	Preference   preference.Handler
+	TraceFunnel  tracefunnel.Handler
 }
 
 func NewHandlers(modules Modules) Handlers {
 	return Handlers{
 		Organization: implorganization.NewHandler(modules.Organization),
 		Preference:   implpreference.NewHandler(modules.Preference),
+		TraceFunnel:  impltracefunnel.NewHandler(modules.TraceFunnel),
 	}
 }

pkg/signoz/module.go

@@ -5,6 +5,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/preference/implpreference"
+	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
+	"github.com/SigNoz/signoz/pkg/modules/tracefunnel/impltracefunnel"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/preferencetypes"
 )
@@ -12,11 +14,13 @@ import (
 type Modules struct {
 	Organization organization.Module
 	Preference   preference.Module
+	TraceFunnel  tracefunnel.Module
 }
 
 func NewModules(sqlstore sqlstore.SQLStore) Modules {
 	return Modules{
 		Organization: implorganization.NewModule(implorganization.NewStore(sqlstore)),
 		Preference:   implpreference.NewModule(implpreference.NewStore(sqlstore), preferencetypes.NewDefaultPreferenceMap()),
+		TraceFunnel:  impltracefunnel.NewModule(impltracefunnel.NewStore(sqlstore)),
 	}
 }

pkg/signoz/provider.go

@@ -76,6 +76,7 @@ func NewSQLMigrationProviderFactories(sqlstore sqlstore.SQLStore) factory.NamedM
 		sqlmigration.NewDropGroupsFactory(sqlstore),
 		sqlmigration.NewCreateQuickFiltersFactory(sqlstore),
 		sqlmigration.NewUpdateQuickFiltersFactory(sqlstore),
+		sqlmigration.NewAddTraceFunnelsFactory(sqlstore),
 	)
 }
 

pkg/sqlmigration/032_add_trace_funnels.go

@@ -0,0 +1,111 @@
+package sqlmigration
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	traceFunnels "github.com/SigNoz/signoz/pkg/types/tracefunnel"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+)
+
+type addTraceFunnels struct {
+	sqlstore sqlstore.SQLStore
+}
+
+func NewAddTraceFunnelsFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.
+		NewProviderFactory(factory.
+			MustNewName("add_trace_funnels"),
+			func(ctx context.Context, providerSettings factory.ProviderSettings, config Config) (SQLMigration, error) {
+				return newAddTraceFunnels(ctx, providerSettings, config, sqlstore)
+			})
+}
+
+func newAddTraceFunnels(_ context.Context, _ factory.ProviderSettings, _ Config, sqlstore sqlstore.SQLStore) (SQLMigration, error) {
+	return &addTraceFunnels{sqlstore: sqlstore}, nil
+}
+
+func (migration *addTraceFunnels) Register(migrations *migrate.Migrations) error {
+	if err := migrations.
+		Register(migration.Up, migration.Down); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (migration *addTraceFunnels) Up(ctx context.Context, db *bun.DB) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	// Create trace_funnel table with foreign key constraint inline
+	_, err = tx.NewCreateTable().
+		Model((*traceFunnels.Funnel)(nil)).
+		ForeignKey(`("org_id") REFERENCES "organizations" ("id") ON DELETE CASCADE`).
+		IfNotExists().
+		Exec(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to create trace_funnel table: %v", err)
+	}
+
+	// Add unique constraint for org_id and name
+	_, err = tx.NewRaw(`
+		CREATE UNIQUE INDEX IF NOT EXISTS idx_trace_funnel_org_id_name 
+		ON trace_funnel (org_id, name)
+	`).Exec(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to create unique constraint: %v", err)
+	}
+
+	// Create indexes
+	_, err = tx.NewCreateIndex().
+		Model((*traceFunnels.Funnel)(nil)).
+		Index("idx_trace_funnel_org_id").
+		Column("org_id").
+		Exec(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to create org_id index: %v", err)
+	}
+
+	_, err = tx.NewCreateIndex().
+		Model((*traceFunnels.Funnel)(nil)).
+		Index("idx_trace_funnel_created_at").
+		Column("created_at").Exec(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to create created_at index: %v", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (migration *addTraceFunnels) Down(ctx context.Context, db *bun.DB) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	// Drop trace_funnel table
+	_, err = tx.NewDropTable().
+		Model((*traceFunnels.Funnel)(nil)).
+		IfExists().
+		Exec(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to drop trace_funnel table: %v", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/types/integration.go

@@ -203,8 +203,7 @@ type CloudIntegrationService struct {
 }
 
 type CloudServiceLogsConfig struct {
-	Enabled   bool                `json:"enabled"`
-	S3Buckets map[string][]string `json:"s3_buckets,omitempty"`
+	Enabled bool `json:"enabled"`
 }
 
 type CloudServiceMetricsConfig struct {

pkg/types/tracefunnel/store.go

@@ -0,0 +1,15 @@
+package tracefunnel
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type FunnelStore interface {
+	Create(context.Context, *Funnel) error
+	Get(context.Context, valuer.UUID) (*Funnel, error)
+	List(context.Context, valuer.UUID) ([]*Funnel, error)
+	Update(context.Context, *Funnel) error
+	Delete(context.Context, valuer.UUID) error
+}

pkg/types/tracefunnel/tracefunnel.go

@@ -0,0 +1,103 @@
+package tracefunnel
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+)
+
+var (
+	ErrFunnelAlreadyExists = errors.MustNewCode("funnel_already_exists")
+)
+
+// BaseMetadata metadata for funnels
+type BaseMetadata struct {
+	types.Identifiable // funnel id
+	types.TimeAuditable
+	types.UserAuditable
+	Name        string      `json:"funnel_name" bun:"name,type:text,notnull"` // funnel name
+	Description string      `json:"description" bun:"description,type:text"`  // funnel description
+	OrgID       valuer.UUID `json:"org_id" bun:"org_id,type:varchar,notnull"`
+}
+
+// Funnel Core Data Structure (Funnel and FunnelStep)
+type Funnel struct {
+	bun.BaseModel `bun:"table:trace_funnel"`
+	BaseMetadata
+	Steps         []FunnelStep `json:"steps" bun:"steps,type:text,notnull"`
+	Tags          string       `json:"tags" bun:"tags,type:text"`
+	CreatedByUser *types.User  `json:"user" bun:"rel:belongs-to,join:created_by=id"`
+}
+
+type FunnelStep struct {
+	ID             valuer.UUID   `json:"id,omitempty"`
+	Name           string        `json:"name,omitempty"`        // step name
+	Description    string        `json:"description,omitempty"` // step description
+	Order          int64         `json:"step_order"`
+	ServiceName    string        `json:"service_name"`
+	SpanName       string        `json:"span_name"`
+	Filters        *v3.FilterSet `json:"filters,omitempty"`
+	LatencyPointer string        `json:"latency_pointer,omitempty"`
+	LatencyType    string        `json:"latency_type,omitempty"`
+	HasErrors      bool          `json:"has_errors"`
+}
+
+// FunnelRequest represents all possible funnel-related requests
+type FunnelRequest struct {
+	FunnelID    valuer.UUID  `json:"funnel_id,omitempty"`
+	Name        string       `json:"funnel_name,omitempty"`
+	Timestamp   int64        `json:"timestamp,omitempty"`
+	Description string       `json:"description,omitempty"`
+	Steps       []FunnelStep `json:"steps,omitempty"`
+	UserID      string       `json:"user_id,omitempty"`
+
+	// Analytics specific fields
+	StartTime  int64 `json:"start_time,omitempty"`
+	EndTime    int64 `json:"end_time,omitempty"`
+	StepAOrder int64 `json:"step_a_order,omitempty"`
+	StepBOrder int64 `json:"step_b_order,omitempty"`
+}
+
+// FunnelResponse represents all possible funnel-related responses
+type FunnelResponse struct {
+	FunnelID    string       `json:"funnel_id,omitempty"`
+	FunnelName  string       `json:"funnel_name,omitempty"`
+	Description string       `json:"description,omitempty"`
+	CreatedAt   int64        `json:"created_at,omitempty"`
+	CreatedBy   string       `json:"created_by,omitempty"`
+	UpdatedAt   int64        `json:"updated_at,omitempty"`
+	UpdatedBy   string       `json:"updated_by,omitempty"`
+	OrgID       string       `json:"org_id,omitempty"`
+	UserEmail   string       `json:"user_email,omitempty"`
+	Funnel      *Funnel      `json:"funnel,omitempty"`
+	Steps       []FunnelStep `json:"steps,omitempty"`
+}
+
+// TimeRange represents a time range for analytics
+type TimeRange struct {
+	StartTime int64 `json:"start_time"`
+	EndTime   int64 `json:"end_time"`
+}
+
+// StepTransitionRequest represents a request for step transition analytics
+type StepTransitionRequest struct {
+	TimeRange
+	StepAOrder int64 `json:"step_start,omitempty"`
+	StepBOrder int64 `json:"step_end,omitempty"`
+}
+
+// UserInfo represents basic user information
+type UserInfo struct {
+	ID    string `json:"id"`
+	Email string `json:"email"`
+}
+
+type FunnelStepFilter struct {
+	StepNumber     int
+	ServiceName    string
+	SpanName       string
+	LatencyPointer string // "start" or "end"
+	CustomFilters  *v3.FilterSet
+}