YiY1ddlmZmZddlmZddlmZ ddlmZm Z erddl m Z mZddlmZmZmZmZmZmZGd d Zy#e $rddl Z e jZdZ Y?wxYw) ) TYPE_CHECKINGcast)contexts)Client)iscoroutinefunctionmarkcoroutinefunctionNc|S)N)funcs e/mnt/e/genesis-system/.venvs/browser-army/lib/python3.12/site-packages/posthog/integrations/django.pyrrs ) HttpRequest HttpResponse)CallableDictAnyOptionalUnion AwaitablecTeZdZdZdZdZdZdZdZdZ dZ dZ d Z d Z d Zd Zy )PosthogContextMiddlewareaMiddleware to automatically track Django requests. This middleware wraps all calls with a posthog context. It attempts to extract the following from the request headers: - Session ID, (extracted from `X-POSTHOG-SESSION-ID`) - Distinct ID, (extracted from `X-POSTHOG-DISTINCT-ID`) - Request URL as $current_url - Request Method as $request_method The context will also auto-capture exceptions and send them to PostHog, unless you disable it by setting `POSTHOG_MW_CAPTURE_EXCEPTIONS` to `False` in your Django settings. The exceptions are captured using the global client, unless the setting `POSTHOG_MW_CLIENT` is set to a custom client instance The middleware behaviour is customisable through 3 additional functions: - `POSTHOG_MW_EXTRA_TAGS`, which is a Callable[[HttpRequest], Dict[str, Any]] expected to return a dictionary of additional tags to be added to the context. - `POSTHOG_MW_REQUEST_FILTER`, which is a Callable[[HttpRequest], bool] expected to return `False` if the request should not be tracked. - `POSTHOG_MW_TAG_MAP`, which is a Callable[[Dict[str, Any]], Dict[str, Any]], which you can use to modify the tags before they're added to the context. You can use the `POSTHOG_MW_TAG_MAP` function to remove any default tags you don't want to capture, or override them with your own values. Context tags are automatically included as properties on all events captured within a context, including exceptions. See the context documentation for more information. The extracted distinct ID and session ID, if found, are used to associate all events captured in the middleware context with the same distinct ID and session as currently active on the frontend. See the documentation for `set_context_session` and `identify_context` for more details. This middleware is hybrid-capable: it supports both WSGI (sync) and ASGI (async) Django applications. The middleware detects at initialization whether the next middleware in the chain is async or sync, and adapts its behavior accordingly. This ensures compatibility with both pure sync and pure async middleware chains, as well as mixed chains in ASGI mode. Tc||_t||_|jr t|ddlm}t |dr1t|jrtd|j|_ nd|_ t |dr1t|jrtd|j|_ nd|_ t |dr1t|jrtd|j|_nd|_t |d r,t|j t"r|j |_nd |_t |d r6t|j&t(rtd |j&|_yd|_y) Nr)settingsPOSTHOG_MW_EXTRA_TAGSz1Optional[Callable[[HttpRequest], Dict[str, Any]]]POSTHOG_MW_REQUEST_FILTERz'Optional[Callable[[HttpRequest], bool]]POSTHOG_MW_TAG_MAPz4Optional[Callable[[Dict[str, Any]], Dict[str, Any]]]POSTHOG_MW_CAPTURE_EXCEPTIONSTPOSTHOG_MW_CLIENTzOptional[Client]) get_responser _is_coroutiner django.confrhasattrcallablerr extra_tagsrrequest_filterrtag_map isinstancerboolcapture_exceptionsrrclient)selfrrs r __init__z!PosthogContextMiddleware.__init__9sZ(0>    !$ '( 84 5(  * *; #C..DO #DO 88 9h  . .? #'922#D  #'D  81 2x  ' '8  F++DL  DL 8< =*  2 2DC '/&L&LD #&*D # 80 1j  & &7 183M3MNDKDKr cP|j|\}}|j|||S)z*Extract tags from request in sync context.)extract_request_user _build_tagsr+requestuser_id user_emails r extract_tagsz%PosthogContextMiddleware.extract_tagsqs.#77@*==r ci}|jjd}|rtj||jjdxs|}|rtj||r||d<|j }|r||d<|j r|j |d<|jr|j|d<|jjd}|r||d<|jjd } | r| |d <|jr$|j|} | r|j| |jr|j|}|S) z Build tags dict from request and user info. Centralized tag extraction logic used by both sync and async paths. zX-POSTHOG-SESSION-IDzX-POSTHOG-DISTINCT-IDemailz $current_urlz$request_methodz $request_pathzX-Forwarded-Forz $ip_addressz User-Agentz $user_agent) headersgetrset_context_sessionidentify_contextbuild_absolute_urimethodpathr$updater&) r+r1r2r3tags session_id distinct_id absolute_url ip_address user_agentextras r r/z$PosthogContextMiddleware._build_tagswsA__(()?@   ( ( 4oo))*ABMg   % %k 2 &DM113 #/D  >>&-nnD" # <<$+LLD !__(():; ",D __((6 ",D  ??OOG,E E" <<<<%D r c>t|dd}|j|S)z7Extract user ID and email from request in sync context.userN)getattr_resolve_user_details)r+r1rGs r r.z-PosthogContextMiddleware.extract_request_users#w-))$//r clK|j|d{\}}|j|||S7w)a Async version of extract_tags for use in async request handling. Uses await request.auser() instead of request.user to avoid SynchronousOnlyOperation in async context. Follows Django's naming convention for async methods (auser, asave, etc.). N)aextract_request_userr/r0s r aextract_tagsz&PosthogContextMiddleware.aextract_tagss;%)$>$>w$GG*==Hs 424cKt|dd}t|r! |d{}|j|Sy7#t$rYywxYww)a& Async version of extract_request_user for use in async request handling. Uses await request.auser() instead of request.user to avoid SynchronousOnlyOperation in async context. Follows Django's naming convention for async methods (auser, asave, etc.). auserN)NN)rHr#rI Exception)r+r1rNrGs r rKz.PosthogContextMiddleware.aextract_request_usersY$/ E? ""W}11$77% "" "s1A ?=?A? A A A  Acd}d}|||fSt|dd}t|r|}|s||fSt|dd}| t|}t|dd}|r t|}||fS)z Extract user ID and email from a user object. Handles both authenticated and unauthenticated users, as well as legacy Django where is_authenticated was a method. Nis_authenticatedFpkr6)rHr#str)r+rGr2r6rQuser_pkr3s r rIz.PosthogContextMiddleware._resolve_user_detailss <E> !#4);UC $ %/1 E> !$d+  'lGT7D1  OE~r c|jr|j|S|jr"|j|s|j|St j |j |j5|j|jD]\}}t j|||j|cdddS#1swYyxYw)z Unified entry point for both sync and async request handling. When sync_capable and async_capable are both True, Django passes requests without conversion. This method detects the mode and routes accordingly. r*N) r __acall__r%rr new_contextr)r*r4itemstagr+r1kvs r __call__z!PosthogContextMiddleware.__call__s   >>'* *""4+>+>w+G((11%%d&=&=dkkR 2 --g6<<>'DAqLLA&'((1  2 2 2s 7ACCcK|jr*|j|s|j|d{Stj|j|j 5|j |d{jD]\}}tj|||j|d{cdddS77T7#1swYyxYww)a Asynchronous entry point for async request handling. This method is called when the middleware chain is async. Uses aextract_tags() which calls request.auser() to avoid SynchronousOnlyOperation when accessing user in async context. NrV) r%rrrXr)r*rLrYrZr[s r rWz"PosthogContextMiddleware.__acall__s   t':':7'C**733 3  ! !$"9"9$++ N 4#11'::AAC #1 Q" #**733  4 44;4  4 4sL2CC /C$C9C:AC>C?C CCCCCc|jr|j|sy|jsy|jr|jj|yddlm}||y)a! Process exceptions from views and downstream middleware. Django calls this WHILE still inside the context created by __call__, so request tags have already been extracted and set. This method just needs to capture the exception directly. Django converts view exceptions into responses before they propagate through the middleware stack, so the context manager in __call__/__acall__ never sees them. Note: Django's process_exception is always synchronous, even for async views. Nr)capture_exception)r%r)r*raposthog)r+r1 exceptionras r process_exceptionz*PosthogContextMiddleware.process_exception$sO   t':':7'C &&  ;; KK ) )) 4 1 i (r N)__name__ __module__ __qualname____doc__ sync_capable async_capabler,r4r/r.rLrKrIr^rWrdr r r rrsH:LM6p> 8t0 >. D2*4$)r r)typingrrrbrposthog.clientr asgiref.syncrr ImportErrorasyncio django.httprrrrrrrrrr r r rqsU&! G5FFg)g)# !55 sAAA