public byte[] WriteTelemetry(ITelemetryEvent telemetryEvent, byte[] encryptionKey = null) { var t = (TelemetryEvent)telemetryEvent; if (t == null) { throw new SerializationException("Unknown telemetry event type"); } byte[] payload; switch (t.Message) { case UavPositionReport r: payload = UavPositionReportSerializer.WriteReport(r); break; default: throw new SerializationException($"Unknown message type: {t.MessageType}"); } var wrapper = new TelemetryWrapper(AutpMessageTypes.UavPosition, payload); byte[] wrapperBytes = TelemetryWrapperSerializer.WriteWrapper(wrapper); wrapperBytes = encryptionKey != null ? EncryptBytes(encryptionKey, t.SequenceNumber, wrapperBytes) : EncryptBytes(t.TelemetryId, t.SequenceNumber, wrapperBytes); var datagram = new UdpTelemetryDatagram(t.TelemetryId, t.SequenceNumber, wrapperBytes, true); return(TelemetryDatagramSerializer.WriteDatagram(datagram)); }
public static void LogInfo(ITelemetryEvent tEvent) { if (tEvent != null) { _client.TrackEvent(tEvent.GetType().Name, tEvent.ToDictionary()); } }
public static void Post(this ITelemetryEvent evnt, Telemetry.Client client = null) { if (client != null) { client.Post(evnt); return; } client = ClientApp.SharedInstance?.Telemetry; if (client == null) { pendingEvents.Add(evnt); return; } pendingEvents.CompleteAdding(); while (pendingEvents.TryTake(out var pendingEvent)) { client.Post(pendingEvent); } client.Post(evnt); }
public void SendTelemetry(ITelemetryEvent dataStructure, string portName, int portNumber, string encryptionKey) { byte[] bytes = _autpService.WriteTelemetry(dataStructure, Convert.FromBase64String(encryptionKey)); IDatagramSender datagramSender = new DatagramSender(portName, portNumber); datagramSender.SendToServer(bytes); }
/// <summary> /// Tracks the event. /// </summary> /// <typeparam name="TEvent">The type of the event.</typeparam> /// <param name="event">The event.</param> /// <param name="ttl">The TTL.</param> public static void TrackEvent <TEvent>(ITelemetryEvent <TEvent> @event, TimeSpan ttl) where TEvent : class, new() { LogConsumer.Trace("Tracking event of type {0}", typeof(TEvent).FullName); foreach (var client in Clients) { client.TrackEvent(@event, ttl); } }
/// <summary> /// Gets the event. /// </summary> /// <typeparam name="TEvent">The type of the event.</typeparam> /// <param name="event">The event.</param> /// <returns>TEvent.</returns> public TEvent GetEvent <TEvent>(ITelemetryEvent <TEvent> @event) where TEvent : class, new() { var valueBytes = _redis.GetDatabase(@event.Category).StringGet(@event.Name, CommandFlags.PreferReplica); return(!valueBytes.HasValue ? null : _redis.Serializer.Deserialize <TEvent>(valueBytes)); }
/// <summary> /// Tracks the event. /// </summary> /// <typeparam name="TEvent">The type of the event.</typeparam> /// <param name="event">The event.</param> /// <param name="ttl">The TTL.</param> public void TrackEvent <TEvent>(ITelemetryEvent <TEvent> @event, TimeSpan ttl) where TEvent : class, new() { _redis.GetDatabase(@event.Category).StringSet( @event.Name, (string)@event.Event.GetSerializer(), ttl, When.Always, CommandFlags.FireAndForget); }
public void Post(ITelemetryEvent evnt) { if (evnt == null) { throw new ArgumentNullException(nameof(evnt)); } Post(evnt.GetType().Name, evnt.GetProperties()); }
public void Send(ITelemetryEvent telemetryEvent) { if (telemetryEvent == null) { throw new ArgumentNullException(nameof(telemetryEvent)); } Send(new ITelemetryEvent[] { telemetryEvent }); }
public void Post(ITelemetryEvent evnt) { if (httpClient == null || !enabled) { return; } PostEventAsync(evnt).Forget(); }
protected TelemetryScopeBase(OperationEvent operationEvent, TelemetryIdentifier telemetryIdentifier, ITelemetryRecorder telemetryRecorder) { //IL_0008: Unknown result type (might be due to invalid IL or missing references) result = (TelemetryResult)0; TelemetryEvent = (telemetryIdentifier ?? throw new ArgumentNullException("telemetryIdentifier")); TelemetryRecorder = (telemetryRecorder ?? throw new ArgumentNullException("telemetryRecorder")); endEvent = new VSTelemetryEvent(operationEvent); rootScope = this; }
private SeverityLevel GetSeverityLevel(ITelemetryEvent telemetryEvent) { if (telemetryEvent == null) { return(SeverityLevel.Information); } TelemetryEvent.Levels level; if (telemetryEvent is TelemetryEvent) { level = (telemetryEvent as TelemetryEvent).LevelValue; } else { if (!string.IsNullOrWhiteSpace(telemetryEvent.Level)) { Enum.TryParse(telemetryEvent.Level, out level); } else { level = TelemetryEvent.Levels.NotSpecified; } } SeverityLevel result; switch (level) { case TelemetryEvent.Levels.Critical: result = SeverityLevel.Critical; break; case TelemetryEvent.Levels.Debug: result = SeverityLevel.Verbose; break; case TelemetryEvent.Levels.Error: result = SeverityLevel.Error; break; case TelemetryEvent.Levels.Information: result = SeverityLevel.Information; break; case TelemetryEvent.Levels.Warning: result = SeverityLevel.Warning; break; default: result = SeverityLevel.Information; break; } return(result); }
public EventObjectStreamContent(Client client, ITelemetryEvent evnt) { this.client = client ?? throw new ArgumentNullException(nameof(client)); this.evnt = evnt ?? throw new ArgumentNullException(nameof(evnt)); EnsureHeaders(); }
public void Send(ITelemetryEvent telemetryEvent) { if (telemetryEvent == null) { throw new ArgumentNullException(nameof(telemetryEvent)); } string eventText = telemetryEvent.ToString(); TelemetryEvent.Levels level; if (telemetryEvent is TelemetryEvent) { level = (telemetryEvent as TelemetryEvent).LevelValue; } else { if (!string.IsNullOrWhiteSpace(telemetryEvent.Level)) { Enum.TryParse(telemetryEvent.Level, out level); } else { level = TelemetryEvent.Levels.NotSpecified; } } switch (level) { case TelemetryEvent.Levels.Critical: _logger.Fatal(eventText, telemetryEvent.Exception); break; case TelemetryEvent.Levels.Debug: _logger.Debug(eventText); break; case TelemetryEvent.Levels.Error: _logger.Error(eventText, telemetryEvent.Exception); break; case TelemetryEvent.Levels.Warning: _logger.Warn(eventText); break; case TelemetryEvent.Levels.Information: case TelemetryEvent.Levels.NotSpecified: default: _logger.Info(eventText); break; } }
/// <summary> /// Gets the event. /// </summary> /// <typeparam name="TEvent">The type of the event.</typeparam> /// <param name="event">The event.</param> /// <returns></returns> public static TEvent GetEvent <TEvent>(ITelemetryEvent <TEvent> @event) where TEvent : class, new() { LogConsumer.Trace("Getting event of type {0} with key {1}", typeof(TEvent).FullName, @event.Name); TEvent result; foreach (var client in Clients) { if ((result = client.GetEvent(@event)) != null) { return(result); } } return(null); }
async Task PostEventOnceAsync(ITelemetryEvent evnt) { var response = await httpClient.PostAsync( "logEvent", new EventObjectStreamContent (this, evnt)); if (response.StatusCode == HttpStatusCode.Forbidden) { Log.Info(TAG, "Disabling telemetry at service's direction (403)."); DisableTelemetry(); return; } response.EnsureSuccessStatusCode(); eventsSent++; Log.Verbose(TAG, $"({eventsSent}): {evnt}"); }
async Task PostEventAsync(ITelemetryEvent evnt) { #pragma warning disable 0168 for (int i = 0; i < 10; i++) { try { await PostEventOnceAsync(evnt); return; } catch (JsonSerializationException e) { Log.Error(TAG, e); return; } catch (Exception e) { #if DEBUG Log.Error(TAG, $"attempt {i} failed", e); #endif } await Task.Delay(TimeSpan.FromMilliseconds(Math.Pow(2, i) * 100)); #pragma warning restore 0168 } }
private void TrackDependency(ITelemetryEvent telemetryEvent) { DependencyTelemetry info = new DependencyTelemetry(); info.Data = telemetryEvent.Data; if (telemetryEvent.Duration != null && telemetryEvent.Duration.HasValue) { info.Duration = telemetryEvent.Duration.Value; } info.Type = telemetryEvent.EventType; info.Id = telemetryEvent.Id; if (!string.IsNullOrWhiteSpace(telemetryEvent.Level)) { info.Properties.Add(nameof(telemetryEvent.Level), telemetryEvent.Level); } if (!string.IsNullOrWhiteSpace(telemetryEvent.Message)) { info.Properties.Add(nameof(telemetryEvent.Message), telemetryEvent.Message); } info.Metrics.AddItems(telemetryEvent.Metrics); info.Name = telemetryEvent.Name; if (!string.IsNullOrWhiteSpace(telemetryEvent.ProblemId)) { info.Properties.Add(nameof(telemetryEvent.ProblemId), telemetryEvent.ProblemId); } info.Properties.AddItems(telemetryEvent.Properties); if (!string.IsNullOrWhiteSpace(telemetryEvent.Protocol)) { info.Properties.Add(nameof(telemetryEvent.Protocol), telemetryEvent.Protocol); } if (!string.IsNullOrWhiteSpace(telemetryEvent.ResponseCode)) { info.Properties.Add(nameof(telemetryEvent.ResponseCode), telemetryEvent.ResponseCode); } info.ResultCode = telemetryEvent.Result; info.Success = telemetryEvent.Success; info.Target = telemetryEvent.Target; if (telemetryEvent.TimeStamp != null) { info.Timestamp = telemetryEvent.TimeStamp.Value; } if (!string.IsNullOrWhiteSpace(telemetryEvent.Uri)) { info.Properties.Add(nameof(telemetryEvent.Uri), telemetryEvent.Uri); } if (!string.IsNullOrWhiteSpace(telemetryEvent.UserId)) { info.Context.User.Id = telemetryEvent.UserId; } if (telemetryEvent.Value != null) { info.Properties.Add(nameof(telemetryEvent.Value), telemetryEvent.Value.Value.ToString()); } this.Client.TrackDependency(info); if (!string.IsNullOrWhiteSpace(telemetryEvent.UserId)) { info.Context.User.Id = string.Empty; } }
private void TrackView(ITelemetryEvent telemetryEvent) { PageViewTelemetry info = new PageViewTelemetry(); if (!string.IsNullOrWhiteSpace(telemetryEvent.Data)) { info.Properties.Add(nameof(telemetryEvent.Data), telemetryEvent.Data); } if (telemetryEvent.Duration != null && telemetryEvent.Duration.HasValue) { info.Properties.Add(nameof(telemetryEvent.Duration), telemetryEvent.Duration.Value.ToString()); } if (!string.IsNullOrWhiteSpace(telemetryEvent.EventType)) { info.Properties.Add(nameof(telemetryEvent.EventType), telemetryEvent.EventType); } if (!string.IsNullOrWhiteSpace(telemetryEvent.Id)) { info.Properties.Add(nameof(telemetryEvent.Id), telemetryEvent.Id); } if (!string.IsNullOrWhiteSpace(telemetryEvent.Level)) { info.Properties.Add(nameof(telemetryEvent.Level), telemetryEvent.Level); } if (!string.IsNullOrWhiteSpace(telemetryEvent.Message)) { info.Properties.Add(nameof(telemetryEvent.Message), telemetryEvent.Message); } info.Metrics.AddItems(telemetryEvent.Metrics); info.Name = telemetryEvent.Name; if (!string.IsNullOrWhiteSpace(telemetryEvent.ProblemId)) { info.Properties.Add(nameof(telemetryEvent.ProblemId), telemetryEvent.ProblemId); } info.Properties.AddItems(telemetryEvent.Properties); if (!string.IsNullOrWhiteSpace(telemetryEvent.Protocol)) { info.Properties.Add(nameof(telemetryEvent.Protocol), telemetryEvent.Protocol); } if (!string.IsNullOrWhiteSpace(telemetryEvent.ResponseCode)) { info.Properties.Add(nameof(telemetryEvent.ResponseCode), telemetryEvent.ResponseCode); } if (!string.IsNullOrWhiteSpace(telemetryEvent.Result)) { info.Properties.Add(nameof(telemetryEvent.Result), telemetryEvent.Result); } if (telemetryEvent.Success != null) { info.Properties.Add(nameof(telemetryEvent.Success), telemetryEvent.Success.Value.ToString()); } if (!string.IsNullOrWhiteSpace(telemetryEvent.Target)) { info.Properties.Add(nameof(telemetryEvent.Target), telemetryEvent.Target); } if (telemetryEvent.TimeStamp != null) { info.Timestamp = telemetryEvent.TimeStamp.Value; } if (!string.IsNullOrWhiteSpace(telemetryEvent.Uri)) { info.Url = new Uri(telemetryEvent.Uri); } if (!string.IsNullOrWhiteSpace(telemetryEvent.UserId)) { info.Context.User.Id = telemetryEvent.UserId; } if (telemetryEvent.Value != null) { info.Properties.Add(nameof(telemetryEvent.Value), telemetryEvent.Value.Value.ToString()); } this.Client.TrackPageView(info); if (!string.IsNullOrWhiteSpace(telemetryEvent.UserId)) { info.Context.User.Id = string.Empty; } }
public void Send(ITelemetryEvent telemetryEvent) { if (telemetryEvent == null) { throw new ArgumentNullException(nameof(telemetryEvent)); } TelemetryEvent.EventTypes eventType; if (telemetryEvent is TelemetryEvent) { eventType = (telemetryEvent as TelemetryEvent).EventTypeValue; } else { if (!string.IsNullOrWhiteSpace(telemetryEvent.EventType)) { Enum.TryParse(telemetryEvent.EventType, out eventType); } else { eventType = TelemetryEvent.EventTypes.NotSpecified; } } switch (eventType) { case TelemetryEvent.EventTypes.Dependency: TrackDependency(telemetryEvent); break; case TelemetryEvent.EventTypes.Event: case TelemetryEvent.EventTypes.NotSpecified: TrackEvent(telemetryEvent); break; case TelemetryEvent.EventTypes.Exception: TrackException(telemetryEvent); break; case TelemetryEvent.EventTypes.Metric: TrackMetric(telemetryEvent); break; case TelemetryEvent.EventTypes.Request: TrackRequest(telemetryEvent); break; case TelemetryEvent.EventTypes.Trace: TrackTrace(telemetryEvent); break; case TelemetryEvent.EventTypes.View: TrackView(telemetryEvent); break; default: TrackEvent(telemetryEvent); break; } }
public static IDictionary <string, string> ToDictionary(this ITelemetryEvent tEvent) { return(tEvent.GetType().GetProperties().Where(p => p.CanRead && p.PropertyType == typeof(string)).ToDictionary(k => k.Name, v => (string)v.GetValue(tEvent))); }