Bijdding van Umami Tracking Client Follow Up
Inleiding
In een eerdere post Ik schatte uit hoe een Tracking Client voor Umami in C# kon werken.
Nou, ik had eindelijk de kans om het uitgebreid te testen en te verbeteren. IHostedService).
Verwonderingen van de Umami API
De Umami Tracking API is zowel zeer beoordeeld als erg kort.. Dus ik moest de clientcode updaten om het volgende te doen.
- De API verwacht een 'realistisch'-aangeziene Gebruiker-Agent-strijd. Dus ik moest de client opdateren om een echte Gebruiker te gebruiken\ -Agents-strijd \ (\ of, om precies te zijn, ik nam een echte gebruiker van een browser en gebruikte die.
- De API verwacht het's JSON-invoer in een zeer specifiek formaat; lege stringen zijn niet toegelaten . Dus ik moest de client updaten om dit te beheren.
- De gemeenschappelijke wetgeving van het land. Node API-kliënt Het heeft een beetje een vreemde oppervlakte.
De Node API-Client
De Node API-client in totaal is onder, het 's super flexibel maar echt niet goed gedocumenteerd.
export interface UmamiOptions {
hostUrl?: string;
websiteId?: string;
sessionId?: string;
userAgent?: string;
}
export interface UmamiPayload {
website: string;
session?: string;
hostname?: string;
language?: string;
referrer?: string;
screen?: string;
title?: string;
url?: string;
name?: string;
data?: {
[key: string]: string | number | Date;
};
}
export interface UmamiEventData {
[key: string]: string | number | Date;
}
export class Umami {
options: UmamiOptions;
properties: object;
constructor(options: UmamiOptions = {}) {
this.options = options;
this.properties = {};
}
init(options: UmamiOptions) {
this.options = { ...this.options, ...options };
}
send(payload: UmamiPayload, type: 'event' | 'identify' = 'event') {
const { hostUrl, userAgent } = this.options;
return fetch(`${hostUrl}/api/send`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'User-Agent': userAgent || `Mozilla/5.0 Umami/${process.version}`,
},
body: JSON.stringify({ type, payload }),
});
}
track(event: object | string, eventData?: UmamiEventData) {
const type = typeof event;
const { websiteId } = this.options;
switch (type) {
case 'string':
return this.send({
website: websiteId,
name: event as string,
data: eventData,
});
case 'object':
return this.send({ website: websiteId, ...(event as UmamiPayload) });
}
return Promise.reject('Invalid payload.');
}
identify(properties: object = {}) {
this.properties = { ...this.properties, ...properties };
const { websiteId, sessionId } = this.options;
return this.send(
{ website: websiteId, session: sessionId, data: { ...this.properties } },
'identify',
);
}
reset() {
this.properties = {};
}
}
const umami = new Umami();
export default umami;
Zoals je ziet, exposeert het de volgende methoden:
init- Om de opties te bepalen.send- Om de payload te sturen.track- Om een gebeurtenis te volgen.identify- Om een gebruiker te identificerenreset- Om de eigenschappen te resetten.
De kern hiervan is de send methode die de payload naar de API stuurt.
send(payload: UmamiPayload, type: 'event' | 'identify' = 'event') {
const { hostUrl, userAgent } = this.options;
return fetch(`${hostUrl}/api/send`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'User-Agent': userAgent || `Mozilla/5.0 Umami/${process.version}`,
},
body: JSON.stringify({ type, payload }),
});
}
De C# Kliënt
Om te beginnen kopieerde ik de Node API client's. UmamiOptions en UmamiPayload Classes (Ik won' ik heb ze niet meer voorbijgetrokken.
Dus nu mijn Send De methode ziet er zo uit:
public async Task<HttpResponseMessage> Send(UmamiPayload? payload=null, UmamiEventData? eventData =null, string type = "event")
{
var websiteId = settings.WebsiteId;
payload = PopulateFromPayload(websiteId, payload, eventData);
var jsonPayload = new { type, payload };
logger.LogInformation("Sending data to Umami: {Payload}", JsonSerializer.Serialize(jsonPayload, options));
var response = await client.PostAsJsonAsync("api/send", jsonPayload, options);
if (!response.IsSuccessStatusCode)
{
logger.LogError("Failed to send data to Umami: {StatusCode}, {ReasonPhrase}", response.StatusCode, response.ReasonPhrase);
}
else
{
var content = await response.Content.ReadAsStringAsync();
logger.LogInformation("Successfully sent data to Umami: {StatusCode}, {ReasonPhrase}, {Content}", response.StatusCode, response.ReasonPhrase, content);
}
return response;
}
Er zijn hier twee cruciale onderdelen van ':
- De gemeenschappelijke wetgeving van het land.
PopulateFromPayloadmethode die de payload bevolkt met de websiteID en het eventData. - De JSON serialisatie van de payload, moet null waardes uitsluiten.
De gemeenschappelijke wetgeving van het land. PopulateFromPayload Methode
public static UmamiPayload PopulateFromPayload(string webSite, UmamiPayload? payload, UmamiEventData? data)
{
var newPayload = GetPayload(webSite, data: data);
if(payload==null) return newPayload;
if(payload.Hostname != null)
newPayload.Hostname = payload.Hostname;
if(payload.Language != null)
newPayload.Language = payload.Language;
if(payload.Referrer != null)
newPayload.Referrer = payload.Referrer;
if(payload.Screen != null)
newPayload.Screen = payload.Screen;
if(payload.Title != null)
newPayload.Title = payload.Title;
if(payload.Url != null)
newPayload.Url = payload.Url;
if(payload.Name != null)
newPayload.Name = payload.Name;
if(payload.Data != null)
newPayload.Data = payload.Data;
return newPayload;
}
private static UmamiPayload GetPayload(string websiteId, string? url = null, UmamiEventData? data = null)
{
var payload = new UmamiPayload
{
Website = websiteId,
Data = data,
Url = url ?? string.Empty
};
return payload;
}
Je kunt zien dat we altijd de websiteId We zetten de andere waardes alleen op als ze niet null zijn.. Dit geeft ons flexibiliteit ten koste van een beetje verbositeit.
De HttpClient Opstelling
Zoals ik al zei, moeten we een enigszins echte User-Agent-string aan de API geven. HttpClient opstelling.
services.AddHttpClient<UmamiClient>((serviceProvider, client) =>
{
umamiSettings = serviceProvider.GetRequiredService<UmamiClientSettings>();
client.DefaultRequestHeaders.Add("User-Agent", $"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36");
client.BaseAddress = new Uri(umamiSettings.UmamiPath);
}).SetHandlerLifetime(TimeSpan.FromMinutes(5)) //Set lifetime to five minutes
.AddPolicyHandler(GetRetryPolicy())
#if DEBUG
.AddLogger<HttpLogger>();
#else
;
#endif
Agtergronddienst
Dit is nog een ander. IHostedServiceEr is een hoop artikels over hoe je ze opstelt, dus ik won.
Het enige pijnpunt was de injectie. HttpClient in de UmamiClient class. Omwille van de schaal van de client & gebruikte ik een IServiceScopeFactory Geïnjecteerd in de constructor van de HostedService, pak hem dan voor elke stuurvraag.
private async Task SendRequest(CancellationToken token)
{
logger.LogInformation("Umami background delivery started");
while (await _channel.Reader.WaitToReadAsync(token))
{
while (_channel.Reader.TryRead(out var payload))
{
try
{
using var scope = scopeFactory.CreateScope();
var client = scope.ServiceProvider.GetRequiredService<UmamiClient>();
// Send the event via the client
await client.Send(payload.Payload);
logger.LogInformation("Umami background event sent: {EventType}", payload.EventType);
}
catch (OperationCanceledException)
{
logger.LogWarning("Umami background delivery canceled.");
return; // Exit the loop on cancellation
}
catch (Exception ex)
{
logger.LogError(ex, "Error sending Umami background event.");
}
}
}
}
De gehosteerde dienst gebruiken
Nu we deze gehosteerde dienst hebben, kunnen we de prestaties dramatisch verbeteren door de gebeurtenissen in de achtergrond te sturen.
Ik heb dit in een paar verschillende plaatsen gebruikt. Program.cs Ik besloot een experiment te doen met het volgen van de RSS-feed-request met middelbare software.
app.Use( async (context, next) =>
{
var path = context.Request.Path.Value;
if (path.EndsWith("RSS", StringComparison.OrdinalIgnoreCase))
{
var rss = context.RequestServices.GetRequiredService<UmamiBackgroundSender>();
// Send the event in the background
await rss.SendBackground(new UmamiPayload(){Url = path, Name = "RSS Feed"});
}
await next();
});
I' heb ook nog meer gegevens doorgegeven van mijn TranslateAPI Endpunt.
Dat laat me zien hoe lang de vertalingen duurt.
await umamiClient.SendBackground(new UmamiPayload(){ Name = "Get Translation"}, new UmamiEventData(){{"timetaken", translationTask.TotalMilliseconds}, {"language",translationTask.Language}});
var result = new TranslateResultTask(translationTask, true);
In slotting:
De Umami API is een beetje bizar, maar het is een geweldige manier om gebeurtenissen zelf te volgen. Additionally van een eerder artikel Ik wil data terugtrekken uit Umami om functies als populariteitsortering te leveren.