# Bijdding van Umami Tracking Client Follow Up

<!--category-- ASP.NET, Umami -->
<datetime class="hidden">2024-08-27T02:00</datetime>

# Inleiding

In een [eerdere post](/blog/addingumamitrackingclient) 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`).

[TOC]

# 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](https://github.com/umami-software/node) 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.

```javascript
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.

```javascript
  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:

```csharp
     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

```csharp
        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.

```csharp
              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. `IHostedService`Er 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.

```csharp
    

    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.

```csharp
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.

```csharp
    
       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](/blog/addingascsharpclientforumamiapi) Ik wil data terugtrekken uit Umami om functies als populariteitsortering te leveren.