// utils
public static void GetActivityDataForWS(int activityId, out int processId, out ActivityKind activityKind, out string activityName, out string SSKey, out string url, out int tenantId)
{
string EspaceName;
string ProcessName;
GetActivityDataForWS(activityId, out processId, out activityKind, out activityName, out SSKey, out url, out tenantId, out EspaceName, out ProcessName);
}
protected void ScheduleActivity(HeContext heContext, int activityId, DateTime startDate)
{
using (Transaction trans = DatabaseAccess.ForSystemDatabase.GetRequestTransaction()) {
int tenantId = heContext.AppInfo.Tenant.Id;
int activityDefId;
using (IDataReader reader = DBRuntimePlatform.Instance.GetActivity(trans, tenantId, activityId, false)) {
if (reader.Read())
{
activityDefId = reader.SafeGet <int>("ACTIVITY_DEF_ID");
}
else
{
throw new InvalidOperationException("Activity '" + Name + "' (#" + activityId + ") does not exist.");
}
}
ActivityKind activityDefKind = DBRuntimePlatform.Instance.GetActivityDefinitionKind(trans, activityDefId);
// Must be an open Human Activity
if (activityDefKind != ActivityKind.HumanActivity)
{
throw new InvalidOperationException("Cannot release activity '" + Name + "' (#" + activityId + ") because it's not an open human activity.");
}
DBRuntimePlatform.Instance.UpdateActivity(trans, tenantId, activityId, null, null, null, null, null, null, null,
ActivityStatus.Scheduled, null, null, null, null, false, startDate, null, null, null, null, null);
}
DatabaseAccess.CommitAllTransactions();
}
public static ResponseData BuildResponseData(ActivityPackage activityPackage)
{
ActivityKind activityKind = activityPackage.ActivityKind;
ResponseData responseData;
switch (activityKind)
{
case ActivityKind.Session:
responseData = new SessionResponseData();
break;
case ActivityKind.Attribution:
responseData = new AttributionResponseData();
break;
case ActivityKind.Event:
responseData = new EventResponseData(activityPackage);
break;
case ActivityKind.Click:
responseData = new SdkClickResponseData();
break;
default:
responseData = new UnknowResponseData();
break;
}
responseData.ActivityKind = activityKind;
return(responseData);
}
public static Activity?Start(
string name,
ActivityKind activityKind,
IMessageConsumeContext context,
IEnumerable <KeyValuePair <string, object?> >?tags = null
)
=> Create(name, activityKind, context, tags)?.Start();
/// <summary>
/// Construct a new <see cref="ActivityCreationOptions{T}"/> object.
/// </summary>
/// <param name="source">The trace Activity source<see cref="ActivitySource"/> used to request creating the Activity object.</param>
/// <param name="name">The operation name of the Activity.</param>
/// <param name="parent">The requested parent to create the Activity object with. The parent either be a parent Id represented as string or it can be a parent context <see cref="ActivityContext"/>.</param>
/// <param name="kind"><see cref="ActivityKind"/> to create the Activity object with.</param>
/// <param name="tags">Key-value pairs list for the tags to create the Activity object with.<see cref="ActivityContext"/></param>
/// <param name="links"><see cref="ActivityLink"/> list to create the Activity object with.</param>
/// <param name="idFormat">The default Id format to use.</param>
internal ActivityCreationOptions(ActivitySource source, string name, T parent, ActivityKind kind, IEnumerable <KeyValuePair <string, object?> >?tags, IEnumerable <ActivityLink>?links, ActivityIdFormat idFormat)
{
Source = source;
Name = name;
Kind = kind;
Parent = parent;
Tags = tags;
Links = links;
IdFormat = idFormat;
if (IdFormat == ActivityIdFormat.Unknown && Activity.ForceDefaultIdFormat)
{
IdFormat = Activity.DefaultIdFormat;
}
_samplerTags = null;
if (parent is ActivityContext ac && ac != default)
{
_context = ac;
if (IdFormat == ActivityIdFormat.Unknown)
{
IdFormat = ActivityIdFormat.W3C;
}
}
public void VerifyActivity(ActivityKind activityKind)
{
var activityName = "TestActivity";
var telemetryItem = this.RunActivityTest((activitySource) =>
{
using (var activity = activitySource.StartActivity(name: activityName, kind: activityKind))
{
activity.SetTag("integer", 1);
activity.SetTag("message", "Hello World!");
activity.SetTag("intArray", new int[] { 1, 2, 3 });
}
});
VerifyTelemetryItem.Verify(
telemetryItem: telemetryItem,
activityKind: activityKind,
expectedVars: new ExpectedTelemetryItemValues
{
Name = activityName,
CustomProperties = new Dictionary <string, string> {
{ "integer", "1" },
{ "message", "Hello World!" },
{ "intArray", "1,2,3" }
}
});
}
private static void ActivityStartChecks(int activityId, string name, ActivityKind activityKind, string SSKey)
{
if (!activityKind.CanBeStarted())
{
throw new InvalidOperationException("Activity '" + name + "' (#" + activityId + ") cannot be started.");
}
}
public void VerifyActivity(ActivityKind activityKind)
{
this.Setup(processor: out BatchExportProcessor <Activity> processor, transmitter: out MockTransmitter transmitter);
var activityName = "TestActivity";
using (var activity = MyActivitySource.StartActivity(name: activityName, kind: activityKind))
{
activity.SetTag("integer", 1);
activity.SetTag("message", "Hello World!");
activity.SetTag("intArray", new int[] { 1, 2, 3 });
}
processor.ForceFlush();
Task.Delay(100).Wait(); //TODO: HOW TO REMOVE THIS WAIT?
Assert.True(transmitter.TelemetryItems.Any(), "test project did not capture telemetry");
var telemetryItem = transmitter.TelemetryItems.First();
VerifyTelemetryItem.Verify(
telemetryItem: telemetryItem,
activityKind: activityKind,
expectedVars: new ExpectedTelemetryItemValues
{
Name = activityName,
CustomProperties = new Dictionary <string, string> {
{ "integer", "1" },
{ "message", "Hello World!" },
{ "intArray", "1,2,3" }
}
});
}
public static int KindOrderNum(this ActivityKind kind)
{
switch (kind)
{
case ActivityKind.ConditionalStart:
return(1);
case ActivityKind.HumanActivity:
return(2);
case ActivityKind.Decision:
return(3);
case ActivityKind.ExecuteProcess:
return(4);
case ActivityKind.WaitActivity:
return(5);
case ActivityKind.Start:
case ActivityKind.End:
return(6);
case ActivityKind.AutomaticActivity:
case ActivityKind.EmailActivity:
return(7);
default:
throw new InvalidOperationException("There's a case missing in this switch");
}
}
public Builder(string name, ActivityKind kind, ActivitySource source, Func <IContext, T, IEnumerable <KeyValuePair <string, object?> > >?getTags)
{
_name = name;
_kind = kind;
_source = source;
_getTags = getTags;
}
private static void RegisterCreationActivity(ActivityKind activityKind, Dictionary <string, object> data,
SPWeb contextWeb,
StreamManager streamManager, ThreadManager threadManager, ActivityManager activityManager)
{
var webId = (Guid)data["Id"];
var activityDateTime = (DateTime)data["ActivityTime"];
Thread thread = threadManager.SaveThread(new Thread
{
Title = (string)data["Title"],
Url = (string)data["URL"],
Kind = ObjectKind.Workspace,
FirstActivityDateTime = activityDateTime,
WebId = webId,
Users = new[] { new User {
Id = (int)data["UserId"], Role = UserRole.Author
} }
});
activityManager.RegisterActivity(new Activity
{
Kind = activityKind,
UserId = (int)data["UserId"],
Thread = thread,
Date = activityDateTime
});
Guid streamId = streamManager.GetGlobalStreamId(webId);
threadManager.AssociateStreams(thread, new[] { streamId });
threadManager.UpdateUsers(thread);
CoreFunctions.setConfigSetting(contextWeb, CREATED_CONFIG_KEY, true.ToString());
}
protected void ReleaseActivity(HeContext heContext, int activityId, bool resetActivityUser)
{
using (Transaction trans = DatabaseAccess.ForSystemDatabase.GetRequestTransaction()) {
int tenantId = heContext.AppInfo.Tenant.Id;
int activityDefId = 0;
using (IDataReader reader = DBRuntimePlatform.Instance.GetActivity(trans, tenantId, activityId, false)) {
if (reader.Read())
{
activityDefId = reader.SafeGet <int>("ACTIVITY_DEF_ID");
}
else
{
throw new DataBaseException("No activity instance found for ActivityId = " + activityId + " with TentantId = " + tenantId);
}
}
ActivityKind activityDefKind = DBRuntimePlatform.Instance.GetActivityDefinitionKind(trans, activityDefId);
// Must be an open Human Activity
if (activityDefKind != ActivityKind.HumanActivity)
{
throw new InvalidOperationException("Cannot release activity '" + Name + "' (#" + activityId + ") because it's not an open human activity.");
}
DBRuntimePlatform.Instance.UpdateActivity(trans, tenantId, activityId, null, null, null, (resetActivityUser? 0: (int?)null),
null, false, null, ActivityStatus.Ready, null, null, null, null, null, null, null, null, null, null, null);
}
DatabaseAccess.CommitAllTransactions();
}
public ActivityAdapter(object?activitySource, DiagnosticSource diagnosticSource, string activityName, ActivityKind kind, object?diagnosticSourceArgs)
{
_activitySource = activitySource;
_diagnosticSource = diagnosticSource;
_activityName = activityName;
_kind = kind;
_diagnosticSourceArgs = diagnosticSourceArgs;
switch (_kind)
{
case ActivityKind.Internal:
AddTag("kind", "internal");
break;
case ActivityKind.Server:
AddTag("kind", "server");
break;
case ActivityKind.Client:
AddTag("kind", "client");
break;
case ActivityKind.Producer:
AddTag("kind", "producer");
break;
case ActivityKind.Consumer:
AddTag("kind", "consumer");
break;
}
}
public void SetActivityKind(ActivityKind activityKind)
{
var activity = new Activity("Test");
activity.Start();
ActivityInstrumentationHelper.SetKindProperty(activity, activityKind);
Assert.Equal(activityKind, activity.Kind);
}
public Pipe(string name, ActivityKind kind, ActivitySource source, Func <IContext, T, IEnumerable <KeyValuePair <string, object?> > >?getTags, IPipe <T> next)
{
_name = name;
_kind = kind;
_source = source;
_getTags = getTags;
_next = next;
}
public ActivityPackage(ActivityKind activityKind, string clientSdk, Dictionary <string, string> parameters)
{
ActivityKind = activityKind;
ClientSdk = clientSdk;
Parameters = parameters;
Path = ActivityKindUtil.GetPath(ActivityKind);
Suffix = ActivityKindUtil.GetSuffix(Parameters);
}
public static Activity?StartActivity(
this ActivitySource activitySource,
Type sourceType,
string operationName,
ActivityKind activityKind = ActivityKind.Internal)
=> activitySource.StartActivity(
sourceType.GetOperationName(operationName),
activityKind);
public IActivity?StartActivity(
string name,
ActivityKind kind,
string parentId,
IEnumerable <KeyValuePair <string, object?> >?tags = null,
IEnumerable <ActivityLink>?links = null,
DateTimeOffset startTime = default) =>
Wrap(activitySource.StartActivity(name, kind, parentId, tags, links, startTime));
public ActivityPackage(ActivityKind activityKind, string clientSdk, Dictionary<string, string> parameters)
{
ActivityKind = activityKind;
ClientSdk = clientSdk;
Parameters = parameters;
Path = ActivityKindUtil.GetPath(ActivityKind);
Suffix = ActivityKindUtil.GetSuffix(Parameters);
}
public void SetKindSimpleActivity(ActivityKind inputOutput)
{
var activity = new Activity("test-activity");
activity.SetKind(inputOutput);
Assert.Equal(inputOutput, activity.Kind);
}
/// <summary>
/// Construct a new <see cref="ActivityCreationOptions{T}"/> object.
/// </summary>
/// <param name="source">The trace Activity source<see cref="ActivitySource"/> used to request creating the Activity object.</param>
/// <param name="name">The operation name of the Activity.</param>
/// <param name="parent">The requested parent to create the Activity object with. The parent either be a parent Id represented as string or it can be a parent context <see cref="ActivityContext"/>.</param>
/// <param name="kind"><see cref="ActivityKind"/> to create the Activity object with.</param>
/// <param name="tags">Key-value pairs list for the tags to create the Activity object with.<see cref="ActivityContext"/></param>
/// <param name="links"><see cref="ActivityLink"/> list to create the Activity object with.</param>
internal ActivityCreationOptions(ActivitySource source, string name, T parent, ActivityKind kind, IEnumerable <KeyValuePair <string, string?> >?tags, IEnumerable <ActivityLink>?links)
{
Source = source;
Name = name;
Kind = kind;
Parent = parent;
Tags = tags;
Links = links;
}
public static string ToString(this ActivityStatus status, ActivityKind kind)
{
if (status == ActivityStatus.Closed && kind.CanBeStarted())
{
return("Started");
}
return(status.ToString());
}
public InstrumentedWorker(string name, ActivityKind kind, Context context, List <KeyValuePair <string, object> > attributes, Action work, ActivitySource source)
{
this.activitySource = source;
this.job = work;
this.attributes = attributes;
this.context = context;
this.activityKind = kind;
this.activityName = name;
}
public void ActivitySourceAdapterSetsKind(ActivityKind kind)
{
var activity = new Activity("test");
activity.Start();
this.activitySourceAdapter.Start(activity, kind);
Assert.Equal(kind, activity.Kind);
}
private static Activity StartRootActivity(
this ActivitySource activitySource,
string name,
ActivityKind kind)
{
Activity.Current = null;
return(activitySource.StartActivity(name, kind));
}
private void LogCancellation(ObjectKind objectKind, ActivityKind activityKind, Dictionary <string, object> data,
SPWeb spWeb,
ProcessActivityEventArgs args)
{
if (!string.IsNullOrEmpty(args.CancellationMessage))
{
_logger.Log(objectKind, activityKind, data, spWeb, args.CancellationMessage);
}
}
public void Start(Activity activity, ActivityKind kind)
{
SetKindProperty(activity, kind);
this.getRequestedDataAction(activity);
if (activity.IsAllDataRequested)
{
activity.SetResource(this.resource);
this.activityProcessor?.OnStart(activity);
}
}
public static string GetPath(ActivityKind activityKind)
{
switch (activityKind)
{
case ActivityKind.Session: return "/session";
case ActivityKind.Event: return "/event";
case ActivityKind.Click: return "/sdk_click";
case ActivityKind.Attribution: return "/attribution";
default: return null;
}
}
private static void ActivityCloseChecks(int activityId, string name, ActivityKind activityKind, string SSKey, string requiredssKey, string actionName, bool skip)
{
if (!activityKind.CanBeClosed())
{
throw new InvalidOperationException("Activity '" + name + "' (#" + activityId + ") cannot be " + (skip ? "skipped" : "closed") + ".");
}
if (!requiredssKey.IsEmpty() && SSKey != requiredssKey)
{
throw new InvalidOperationException("Invalid use of activity '" + name + "' identifier in action " + actionName);
}
}
/// <summary>
/// Helper method that populates span properties from http status code according
/// to https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#status.
/// </summary>
/// <param name="kind">The span kind.</param>
/// <param name="httpStatusCode">Http status code.</param>
/// <returns>Resolved span <see cref="Status"/> for the Http status code.</returns>
public static Status ResolveSpanStatusForHttpStatusCode(ActivityKind kind, int httpStatusCode)
{
var upperBound = kind == ActivityKind.Client ? 399 : 499;
if (httpStatusCode >= 100 && httpStatusCode <= upperBound)
{
return(Status.Unset);
}
return(Status.Error);
}
public ProcessActivityEventArgs(ObjectKind objectKind, ActivityKind activityKind,
Dictionary <string, object> data, SPWeb contextWeb,
StreamManager streamManager, ThreadManager threadManager, ActivityManager activityManager)
{
_objectKind = objectKind;
_activityKind = activityKind;
_data = data;
_contextWeb = contextWeb;
_streamManager = streamManager;
_threadManager = threadManager;
_activityManager = activityManager;
}
public void Start(Activity activity, ActivityKind kind, ActivitySource source)
{
OpenTelemetrySdkEventSource.Log.ActivityStarted(activity);
SetActivitySourceProperty(activity, source);
SetKindProperty(activity, kind);
this.getRequestedDataAction(activity);
if (activity.IsAllDataRequested)
{
this.activityProcessor?.OnStart(activity);
}
}
public static string ToString(ActivityKind activityKind)
{
return activityKind.ToString().ToLower();
}
