refactor: remove logEvent calls and related code from components to streamline functionality

apps/web/src/components/Common/Layout.tsx

···
 import Navbar from "@/components/Shared/Navbar";
 import BottomNavigation from "@/components/Shared/Navbar/BottomNavigation";
 import { Spinner } from "@/components/Shared/UI";
-import logEvent from "@/helpers/logEvent";
 import reloadAllTabs from "@/helpers/reloadAllTabs";
 import { useTheme } from "@/hooks/useTheme";
 import { useAccountStore } from "@/store/persisted/useAccountStore";
···
 
   useEffect(() => {
     window.scrollTo(0, 0);
-    void logEvent(`User Event: Page View - ${pathname}`);
   }, [pathname]);
 
   const onError = useCallback(() => {

apps/web/src/components/Common/Providers/index.tsx

···
-import { ApolloLink, ApolloProvider, from } from "@apollo/client";
+import { ApolloProvider } from "@apollo/client";
 import { createApolloClient } from "@hey/indexer/apollo/client";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import type { ReactNode } from "react";
 import { HelmetProvider } from "react-helmet-async";
 import ErrorBoundary from "@/components/Common/ErrorBoundary";
 import authLink from "@/helpers/authLink";
-import logEvent from "@/helpers/logEvent";
 import { ThemeProvider } from "@/hooks/useTheme";
 import Web3Provider from "./Web3Provider";
 
···
   defaultOptions: { queries: { refetchOnWindowFocus: false } }
 });
 
-const logLink = new ApolloLink((operation, forward) => {
-  try {
-    const defs = operation.query.definitions as Array<{
-      kind?: string;
-      operation?: string;
-    }>;
-    const opType =
-      defs?.find((d) => d.kind === "OperationDefinition")?.operation || "query";
-    const name = operation.operationName || "anonymous";
-    const variables = operation.variables || {};
-
-    void logEvent(`GraphQL ${opType}: ${name} - ${JSON.stringify(variables)}`);
-  } catch {}
-
-  return forward(operation);
-});
-
-const lensApolloClient = createApolloClient(from([logLink, authLink]));
+const lensApolloClient = createApolloClient(authLink);
 
 interface ProvidersProps {
   children: ReactNode;

apps/web/src/components/Post/FullPost.tsx

···
   getBlockedByMeMessage,
   getBlockedMeMessage
 } from "@/helpers/getBlockedMessage";
-import usePostView from "@/hooks/usePostView";
 import { useHiddenCommentFeedStore } from ".";
 import PostActions from "./Actions";
 import HiddenPost from "./HiddenPost";
···
 
   const targetPost = isRepost(post) ? post?.repostOf : post;
   const { timestamp } = targetPost;
-  usePostView({ slug: targetPost.slug });
 
   const isBlockedByMe = post.author.operations?.isBlockedByMe;
   const hasBlockedMe = post.author.operations?.hasBlockedMe;

apps/web/src/components/Settings/Developer/Tokens.tsx

···
 import BackButton from "@/components/Shared/BackButton";
 import { Button, Card, CardHeader, H6 } from "@/components/Shared/UI";
 import errorToast from "@/helpers/errorToast";
-import logEvent from "@/helpers/logEvent";
 import useCopyToClipboard from "@/hooks/useCopyToClipboard";
 import useHandleWrongNetwork from "@/hooks/useHandleWrongNetwork";
 import { hydrateAuthTokens } from "@/store/persisted/useAuthStore";
···
   }, []);
 
   const { signMessageAsync } = useSignMessage({
-    mutation: {
-      onError,
-      onSuccess: () => void logEvent("Viem: Token Sign Message")
-    }
+    mutation: { onError }
   });
   const [loadChallenge] = useChallengeMutation();
   const [authenticate] = useAuthenticateMutation();

apps/web/src/components/Shared/Auth/Login.tsx

···
 import Loader from "@/components/Shared/Loader";
 import { Button, Card, ErrorMessage } from "@/components/Shared/UI";
 import errorToast from "@/helpers/errorToast";
-import logEvent from "@/helpers/logEvent";
 import reloadAllTabs from "@/helpers/reloadAllTabs";
 import { signIn } from "@/store/persisted/useAuthStore";
 import { EXPANSION_EASE } from "@/variants";
···
   const { disconnect } = useDisconnect();
   const { address, connector: activeConnector } = useAccount();
   const { signMessageAsync } = useSignMessage({
-    mutation: {
-      onError,
-      onSuccess: () => void logEvent("Viem: Login Sign Message")
-    }
+    mutation: { onError }
   });
   const [loadChallenge, { error: errorChallenge }] = useChallengeMutation({
     onError

apps/web/src/components/Shared/Auth/Signup/ChooseUsername.tsx

···
 import AuthMessage from "@/components/Shared/Auth/AuthMessage";
 import { Button, Form, Input, useZodForm } from "@/components/Shared/UI";
 import errorToast from "@/helpers/errorToast";
-import logEvent from "@/helpers/logEvent";
 import uploadMetadata from "@/helpers/uploadMetadata";
 import useHandleWrongNetwork from "@/hooks/useHandleWrongNetwork";
 import useTransactionLifecycle from "@/hooks/useTransactionLifecycle";
···
     errorToast(error);
   }, []);
 
-  const { signMessageAsync } = useSignMessage({
-    mutation: {
-      onError,
-      onSuccess: () => void logEvent("Viem: Signup Sign Message")
-    }
-  });
+  const { signMessageAsync } = useSignMessage({ mutation: { onError } });
   const [loadChallenge] = useChallengeMutation({ onError });
   const [authenticate] = useAuthenticateMutation({ onError });
 

apps/web/src/components/Shared/Post/PostWrapper.tsx

···
 import type { AnyPostFragment } from "@hey/indexer";
 import type { ReactNode } from "react";
-import { memo, useEffect, useRef } from "react";
+import { memo, useRef } from "react";
 import { useNavigate } from "react-router";
-import { hono } from "@/helpers/fetcher";
 import { usePostLinkStore } from "@/store/non-persisted/navigation/usePostLinkStore";
-import { useAccountStore } from "@/store/persisted/useAccountStore";
 
 interface PostWrapperProps {
   children: ReactNode | ReactNode[];
···
 const PostWrapper = ({ children, className = "", post }: PostWrapperProps) => {
   const navigate = useNavigate();
   const { setCachedPost } = usePostLinkStore();
-  const { currentAccount } = useAccountStore();
   const rootRef = useRef<HTMLElement>(null);
-  const hasLoggedRef = useRef(false);
 
   const handleClick = () => {
     const selection = window.getSelection();
···
       navigate(`/posts/${post.slug}`);
     }
   };
-
-  useEffect(() => {
-    if (!rootRef.current || hasLoggedRef.current) return;
-    const el = rootRef.current;
-    const observer = new IntersectionObserver(
-      (entries) => {
-        const entry = entries[0];
-        if (entry?.isIntersecting && !hasLoggedRef.current) {
-          hasLoggedRef.current = true;
-          try {
-            void hono.impressions.create({
-              address: currentAccount?.address,
-              post: post.slug
-            });
-          } catch {}
-          observer.unobserve(el);
-        }
-      },
-      { threshold: 0.5 }
-    );
-    observer.observe(el);
-    return () => observer.disconnect();
-  }, [currentAccount?.address, post.slug]);
 
   return (
     <article className={className} onClick={handleClick} ref={rootRef}>

apps/web/src/components/Shared/Sidebar/BetaBanner.tsx

···
 import { toast } from "sonner";
 import { Button, Card, H5 } from "@/components/Shared/UI";
 import errorToast from "@/helpers/errorToast";
-import logEvent from "@/helpers/logEvent";
 import useTransactionLifecycle from "@/hooks/useTransactionLifecycle";
 import useWaitForTransactionToComplete from "@/hooks/useWaitForTransactionToComplete";
 import { useAccountStore } from "@/store/persisted/useAccountStore";
···
     onCompleted: () => {
       toast.success("Dismissed");
       setBetaBannerDismissed(true);
-      void logEvent("Dismiss Beta Banner");
     },
     onError,
     variables: { request: { post: BANNER_IDS.BETA } }

apps/web/src/components/Shared/Sidebar/ProBanner.tsx

···
 import { toast } from "sonner";
 import { Button, Card, H5 } from "@/components/Shared/UI";
 import errorToast from "@/helpers/errorToast";
-import logEvent from "@/helpers/logEvent";
 import { useProModalStore } from "@/store/non-persisted/modal/useProModalStore";
 import { useAccountStore } from "@/store/persisted/useAccountStore";
 import { useProStore } from "@/store/persisted/useProStore";
···
     onCompleted: () => {
       toast.success("Dismissed");
       setProBannerDismissed(true);
-      void logEvent("Dismiss Pro Banner");
     },
     onError,
     variables: { request: { post: BANNER_IDS.BETA } }

apps/web/src/helpers/fetcher.ts

···
 };
 
 export const hono = {
-  events: {
-    create: async (payload: { event: string }) =>
-      fetch("https://yoginth.com/api/hey/events", {
-        body: JSON.stringify(payload),
-        headers: {
-          accept: "application/json",
-          "content-type": "application/json"
-        },
-        method: "POST"
-      })
-  },
-  impressions: {
-    create: async (payload: { post: string; address?: string }) =>
-      fetch("https://yoginth.com/api/hey/impressions", {
-        body: JSON.stringify(payload),
-        headers: {
-          accept: "application/json",
-          "content-type": "application/json"
-        },
-        method: "POST"
-      })
-  },
   metadata: {
     sts: (): Promise<STS> => {
       return fetchApi<STS>("/metadata/sts", { method: "GET" });

apps/web/src/helpers/logEvent.ts

···
-import { hono } from "@/helpers/fetcher";
-
-const logEvent = async (event: string) => {
-  try {
-    await hono.events.create({ event });
-  } catch {}
-};
-
-export default logEvent;

apps/web/src/helpers/tokenManager.ts

···
 import apolloClient from "@hey/indexer/apollo/client";
 import type { JwtPayload } from "@hey/types/jwt";
 import { signIn, signOut } from "@/store/persisted/useAuthStore";
-import logEvent from "./logEvent";
 
 let refreshPromise: Promise<string> | null = null;
 const MAX_RETRIES = 5;
···
         if (!newAccessToken || !newRefreshToken) {
           throw new Error("Missing tokens in refresh response");
         }
-
-        try {
-          void logEvent("GraphQL mutation: Refresh");
-        } catch {}
 
         signIn({
           accessToken: newAccessToken,

apps/web/src/hooks/usePostView.tsx

···
-import { useEffect, useMemo } from "react";
-import { hono } from "@/helpers/fetcher";
-import { useAccountStore } from "@/store/persisted/useAccountStore";
-
-const sentImpressions = new Set<string>();
-
-interface UsePostViewOptions {
-  slug: string;
-}
-
-const usePostView = ({ slug }: UsePostViewOptions) => {
-  const key = useMemo(() => `${slug}`, [slug]);
-  const { currentAccount } = useAccountStore();
-
-  useEffect(() => {
-    if (!slug) return;
-    if (sentImpressions.has(key)) return;
-    sentImpressions.add(key);
-    try {
-      void hono.impressions.create({
-        address: currentAccount?.address,
-        post: slug
-      });
-    } catch {}
-  }, [currentAccount?.address, key, slug]);
-};
-
-export default usePostView;