Back to "Bijdding van Umami Tracking Client Follow Up"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

This is a preview from the server running through my markdig pipeline

ASP.NET Umami

Bijdding van Umami Tracking Client Follow Up

Tuesday, 27 August 2024

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.

  1. 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.
  2. 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.
  3. 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:

  1. init - Om de opties te bepalen.
  2. send - Om de payload te sturen.
  3. track - Om een gebeurtenis te volgen.
  4. identify - Om een gebruiker te identificeren
  5. reset - 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 ':

  1. De gemeenschappelijke wetgeving van het land. PopulateFromPayload methode die de payload bevolkt met de websiteID en het eventData.
  2. 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.

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.