public async Task<string> Metric(QueryType queryType, string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { if (queryType == null) throw new ArgumentNullException("queryType"); if (string.IsNullOrWhiteSpace(collection)) throw new ArgumentNullException("collection"); if (string.IsNullOrWhiteSpace(targetProperty) && (queryType!=QueryType.Count())) throw new ArgumentNullException("targetProperty"); var parms = new Dictionary<string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); var reply = await KeenWebApiRequest(queryType.ToString(), parms); string result; if (queryType == QueryType.SelectUnique()) // This is to support SelectUnique which is the only query type with a list-type result. result = string.Join(",", (reply.Value<JArray>("result").Values<string>())); else result = reply.Value<string>("result"); return result; }
/// <summary> /// Run a query returning a single value. /// </summary> /// <param name="queryType">Type of query to run.</param> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task <string> QueryAsync(QueryType queryType, string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "") { return (await Queries.Metric(queryType, collection, targetProperty, timeframe, filters, timezone) .ConfigureAwait(false)); }
/// <summary> /// Run multiple types of analysis over the same data. /// Each item represents one interval. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="analysisParams">Defines the multiple types of analyses to perform.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task <IEnumerable <QueryIntervalValue <IDictionary <string, string> > > > QueryMultiAnalysisIntervalAsync( string collection, IEnumerable <MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string timezone = "") { return (await Queries.MultiAnalysis(collection, analysisParams, timeframe, interval, filters, timezone) .ConfigureAwait(false)); }
QueryMultiAnalysisIntervalGroupAsync(string collection, IEnumerable <MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string groupBy = "", string timezone = "") { return (await Queries.MultiAnalysis(collection, analysisParams, timeframe, interval, filters, groupBy, timezone) .ConfigureAwait(false)); }
/// <summary> /// Return a single value. /// </summary> /// <param name="queryType">Type of query to run.</param> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public string Query(QueryType queryType, string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "") { try { return(QueryAsync(queryType, collection, targetProperty, timeframe, filters, timezone).Result); } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Extract full-form event data with all property values. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="latest">Request up to 100 of the most recent events added to a given collection.</param> /// <param name="email">If specified, email will be sent when the data is ready for download. Otherwise, it will be returned directly.</param> /// <returns></returns> public IEnumerable <dynamic> QueryExtractResource(string collection, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, int latest = 0, string email = "") { try { return(QueryExtractResourceAsync(collection, timeframe, filters, latest, email).Result); } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Funnels count relevant events in succession. See API documentation for details. /// </summary> /// <param name="steps">Analysis steps for funnel.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public FunnelResult QueryFunnel(IEnumerable <FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { try { return(QueryFunnelAsync(steps, timeframe, timezone).Result); } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
public async Task <IEnumerable <dynamic> > Extract(string collection, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, int latest = 0, string email = "") { var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); parms.Add(KeenConstants.QueryParmEmail, email); parms.Add(KeenConstants.QueryParmLatest, latest > 0 ? latest.ToString() : ""); var reply = await KeenWebApiRequest(KeenConstants.QueryExtraction, parms); return(from i in reply.Value <JArray>("result") select(dynamic) i); }
/// <summary> /// Run multiple types of analysis over the same data. /// Each item represents one interval. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="analysisParams">Defines the multiple types of analyses to perform.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IEnumerable <QueryIntervalValue <IDictionary <string, string> > > QueryMultiAnalysisInterval( string collection, IEnumerable <MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string timezone = "") { try { return (QueryMultiAnalysisIntervalAsync(collection, analysisParams, timeframe, interval, filters, timezone) .Result); } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
QueryMultiAnalysisIntervalGroup(string collection, IEnumerable <MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string groupBy = "", string timezone = "") { try { return (QueryMultiAnalysisIntervalGroupAsync(collection, analysisParams, timeframe, interval, filters, groupBy, timezone).Result); } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
public async Task <FunnelResult> Funnel(IEnumerable <FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { var jObs = steps.Select(i => JObject.FromObject(i)); var stepsJson = new JArray(jObs).ToString(); var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmSteps, stepsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryFunnel, parms).ConfigureAwait(false); var o = reply.ToObject <FunnelResult>(); return(o); }
/// <summary> /// Returns counts of unique resources in the event collection. /// Each item contains information about the groupings in that interval. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="groupBy">Name of field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<int>>>> QueryCountUniqueIntervalGroup(string collection, string targetProperty, string groupBy, QueryTimeframe timeframe, QueryInterval interval, IEnumerable<QueryFilter> filters = null, string timezone = "") { try { return QueryCountUniqueIntervalGroupAsync(collection, targetProperty, groupBy, timeframe, interval, filters, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Returns the number of resources in the event collection, grouped by the specified field. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="groupBy">Name of a collection field by which to group counts.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<QueryGroupValue<int>>> QueryCountGroupAsync(string collection, string groupBy, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric<int>(KeenConstants.QueryCount, collection, "-", groupBy, timeframe, filters, timezone).ConfigureAwait(false); ; }
/// <summary> /// Returns the number of unique resources in the event collection. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<int> QueryCountUniqueAsync(string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric<int>(KeenConstants.QueryCountUnique,collection, targetProperty, timeframe, filters, timezone ).ConfigureAwait(false); }
/// <summary> /// Run multiple types of analysis over the same data. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="analysisParams">Defines the multiple types of analyses to perform.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IDictionary<string, string> QueryMultiAnalysis(string collection, IEnumerable<MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { try { return QueryMultiAnalysisAsync(collection, analysisParams, timeframe, filters, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Run multiple types of analysis over the same data. /// Each item contains information about the groupings in that interval. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="analysisParams">Defines the multiple types of analyses to perform.</param> /// <param name="groupBy">Name of field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<IDictionary<string, string>>>>> QueryMultiAnalysisIntervalGroup(string collection, IEnumerable<MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable<QueryFilter> filters = null, string groupBy = "", string timezone = "") { try { return QueryMultiAnalysisIntervalGroupAsync(collection, analysisParams, timeframe, interval, filters, groupBy, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Extract full-form event data with all property values. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="latest">Request up to 100 of the most recent events added to a given collection.</param> /// <param name="email">If specified, email will be sent when the data is ready for download. Otherwise, it will be returned directly.</param> /// <returns></returns> public IEnumerable<dynamic> QueryExtractResource(string collection, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, int latest = 0, string email = "") { try { return QueryExtractResourceAsync(collection, timeframe, filters, latest, email).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Funnels count relevant events in succession. See API documentation for details. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="steps">Analysis steps for funnel.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IEnumerable<int> QueryFunnel(string collection, IEnumerable<FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { try { return QueryFunnelAsync(collection, steps, timeframe, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
public async Task<IEnumerable<dynamic>> Extract(string collection, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, int latest = 0, string email = "") { var parms = new Dictionary<string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); parms.Add(KeenConstants.QueryParmEmail, email); parms.Add(KeenConstants.QueryParmLatest, latest > 0 ? latest.ToString() : ""); var reply = await KeenWebApiRequest(KeenConstants.QueryExtraction, parms); return from i in reply.Value<JArray>("result") select (dynamic)i; }
public async Task<IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<string>>>>> Metric(QueryType queryType, string collection, string targetProperty, string groupby, QueryTimeframe timeframe, QueryInterval interval, IEnumerable<QueryFilter> filters = null, string timezone = "") { if (queryType == null) throw new ArgumentNullException("queryType"); if (string.IsNullOrWhiteSpace(collection)) throw new ArgumentNullException("collection"); if (string.IsNullOrWhiteSpace(targetProperty) && (queryType != QueryType.Count())) throw new ArgumentNullException("targetProperty"); if (null == timeframe) throw new ArgumentException("timeframe", "Timeframe must be specified for a series query."); if (null == interval) throw new ArgumentNullException("interval", "interval must be specified for a series query"); if (string.IsNullOrWhiteSpace(groupby)) throw new ArgumentNullException("groupby", "groupby field name must be specified for a goupby query"); var parms = new Dictionary<string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty); parms.Add(KeenConstants.QueryParmGroupBy, groupby); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); var reply = await KeenWebApiRequest(queryType.ToString(), parms); IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<string>>>> result; if (queryType == QueryType.SelectUnique()) { // This is to support SelectUnique which is the only query type with a list-type result. result = from i in reply.Value<JArray>("result") let v = (from r in i.Value<JArray>("value") let c = string.Join(",", r.Value<JArray>("result").Values<string>()) let g = r.Value<string>(groupby) select new QueryGroupValue<string>(c, g)) let t = i.Value<JObject>("timeframe") select new QueryIntervalValue<IEnumerable<QueryGroupValue<string>>>(v, t.Value<DateTime>("start"), t.Value<DateTime>("end")); } else { result = from i in reply.Value<JArray>("result") let v = (from r in i.Value<JArray>("value") let c = r.Value<string>("result") let g = r.Value<string>(groupby) select new QueryGroupValue<string>(c, g)) let t = i.Value<JObject>("timeframe") select new QueryIntervalValue<IEnumerable<QueryGroupValue<string>>>(v, t.Value<DateTime>("start"), t.Value<DateTime>("end")); } return result; }
public async Task<IEnumerable<int>> Funnel(string collection, IEnumerable<FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { var jObs = steps.Select(i=>JObject.FromObject(i)); var stepsJson = new JArray( jObs ).ToString(); var parms = new Dictionary<string, string>(); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmSteps, stepsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryFunnel, parms); return from i in reply.Value<JArray>("result") select (int)i; }
/// <summary> /// Funnels count relevant events in succession. See API documentation for details. /// </summary> /// <param name="steps">Analysis steps for funnel.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task <FunnelResult> QueryFunnelAsync(IEnumerable <FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { return(await Queries.Funnel(steps, timeframe, timezone).ConfigureAwait(false)); }
/// <summary> /// Extract full-form event data with all property values. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="latest">Request up to 100 of the most recent events added to a given collection.</param> /// <param name="email">If specified, email will be sent when the data is ready for download. Otherwise, it will be returned directly.</param> /// <returns></returns> public async Task <IEnumerable <dynamic> > QueryExtractResourceAsync(string collection, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, int latest = 0, string email = "") { return(await Queries.Extract(collection, timeframe, filters, latest, email).ConfigureAwait(false)); }
/// <summary> /// Returns items collected by time interval and group. /// </summary> /// <param name="queryType">Type of query to run.</param> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="groupBy">Name of field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > QueryIntervalGroup( QueryType queryType, string collection, string targetProperty, string groupBy, QueryTimeframe timeframe, QueryInterval interval, IEnumerable <QueryFilter> filters = null, string timezone = "") { try { return (QueryIntervalGroupAsync(queryType, collection, targetProperty, groupBy, timeframe, interval, filters, timezone).Result); } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Returns items collected by time interval and group. /// </summary> /// <param name="queryType">Type of query to run.</param> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="groupBy">Name of field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task <IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > > QueryIntervalGroupAsync (QueryType queryType, string collection, string targetProperty, string groupBy, QueryTimeframe timeframe, QueryInterval interval, IEnumerable <QueryFilter> filters = null, string timezone = "") { return (await Queries.Metric(queryType, collection, targetProperty, groupBy, timeframe, interval, filters, timezone).ConfigureAwait(false)); }
/// <summary> /// Returns the minimum value for the target property in the event collection. /// Results are grouped by the value of the groupBy field. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="groupBy">Name of a collection field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<QueryGroupValue<string>>> QueryMinimumGroupAsync(string collection,string targetProperty, string groupBy, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric<string>(KeenConstants.QueryMinimum, collection, targetProperty, groupBy, timeframe, filters, timezone).ConfigureAwait(false); }
public async Task<FunnelResult> Funnel(IEnumerable<FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { var jObs = steps.Select(i => JObject.FromObject(i)); var stepsJson = new JArray(jObs).ToString(); var parms = new Dictionary<string, string>(); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmSteps, stepsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryFunnel, parms).ConfigureAwait(false); var o = reply.ToObject<FunnelResult>(); return o; }
public async Task<IDictionary<string,string>> MultiAnalysis(string collection, IEnumerable<MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { var jObs = analysisParams.Select(x => new JProperty( x.Label, JObject.FromObject( new {analysis_type = x.Analysis, target_property = x.TargetProperty }))); var parmsJson = JsonConvert.SerializeObject(new JObject(jObs), Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); var parms = new Dictionary<string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); parms.Add(KeenConstants.QueryParmAnalyses, parmsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms); var result = new Dictionary<string, string>(); foreach (JProperty i in reply.Value<JObject>("result").Children()) result.Add(i.Name, (string)i.Value); return result; }
/// <summary> /// Funnels count relevant events in succession. See API documentation for details. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="steps">Analysis steps for funnel.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task <IEnumerable <int> > QueryFunnelAsync(string collection, IEnumerable <FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { return(await Queries.Funnel(collection, steps, timeframe, timezone).ConfigureAwait(false)); }
/// <summary> /// Funnels count relevant events in succession. See API documentation for details. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="steps">Analysis steps for funnel.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<int>> QueryFunnelAsync(string collection,IEnumerable<FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { return await Queries.Funnel(collection, steps, timeframe, timezone).ConfigureAwait(false); }
/// <summary> /// Returns the maximum value for the target property, grouped by the specified field. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="groupBy">Name of a collection field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IEnumerable<QueryGroupValue<string>> QueryMaximumGroup(string collection, string targetProperty, string groupBy, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { try { return QueryMaximumGroupAsync(collection, targetProperty, groupBy, timeframe, filters, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Run multiple types of analysis over the same data. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="analysisParams">Defines the multiple types of analyses to perform.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IDictionary<string, string>> QueryMultiAnalysisAsync(string collection,IEnumerable<MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.MultiAnalysis(collection, analysisParams, timeframe, filters, timezone).ConfigureAwait(false); }
public async Task <IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > > Metric(QueryType queryType, string collection, string targetProperty, string groupby, QueryTimeframe timeframe, QueryInterval interval, IEnumerable <QueryFilter> filters = null, string timezone = "") { if (queryType == null) { throw new ArgumentNullException("queryType"); } if (string.IsNullOrWhiteSpace(collection)) { throw new ArgumentNullException("collection"); } if (string.IsNullOrWhiteSpace(targetProperty) && (queryType != QueryType.Count())) { throw new ArgumentNullException("targetProperty"); } if (null == timeframe) { throw new ArgumentException("timeframe", "Timeframe must be specified for a series query."); } if (null == interval) { throw new ArgumentNullException("interval", "interval must be specified for a series query"); } if (string.IsNullOrWhiteSpace(groupby)) { throw new ArgumentNullException("groupby", "groupby field name must be specified for a goupby query"); } var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty); parms.Add(KeenConstants.QueryParmGroupBy, groupby); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); var reply = await KeenWebApiRequest(queryType.ToString(), parms); IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > result; if (queryType == QueryType.SelectUnique()) { // This is to support SelectUnique which is the only query type with a list-type result. result = from i in reply.Value <JArray>("result") let v = (from r in i.Value <JArray>("value") let c = string.Join(",", r.Value <JArray>("result").Values <string>()) let g = r.Value <string>(groupby) select new QueryGroupValue <string>(c, g)) let t = i.Value <JObject>("timeframe") select new QueryIntervalValue <IEnumerable <QueryGroupValue <string> > >(v, t.Value <DateTime>("start"), t.Value <DateTime>("end")); } else { result = from i in reply.Value <JArray>("result") let v = (from r in i.Value <JArray>("value") let c = r.Value <string>("result") let g = r.Value <string>(groupby) select new QueryGroupValue <string>(c, g)) let t = i.Value <JObject>("timeframe") select new QueryIntervalValue <IEnumerable <QueryGroupValue <string> > >(v, t.Value <DateTime>("start"), t.Value <DateTime>("end")); } return(result); }
/// <summary> /// Run multiple types of analysis over the same data. /// Each item contains information about the groupings in that interval. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="analysisParams">Defines the multiple types of analyses to perform.</param> /// <param name="groupBy">Name of field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<IDictionary<string, string>>>>>> QueryMultiAnalysisIntervalGroupAsync(string collection, IEnumerable<MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable<QueryFilter> filters = null, string groupBy = "", string timezone = "") { return await Queries.MultiAnalysis(collection, analysisParams, timeframe, interval, filters, groupBy, timezone).ConfigureAwait(false); }
public async Task <IEnumerable <int> > Funnel(string collection, IEnumerable <FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { var jObs = steps.Select(i => JObject.FromObject(i)); var stepsJson = new JArray(jObs).ToString(); var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmSteps, stepsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryFunnel, parms); return(from i in reply.Value <JArray>("result") select(int) i); }
/// <summary> /// Returns the number of resources in the event collection. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public int QueryCount(string collection, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { try { return QueryCountAsync(collection, timeframe, filters, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
public async Task <IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > > > > MultiAnalysis(string collection, IEnumerable <MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string groupby = "", string timezone = "") { var jObs = analysisParams.Select(x => new JProperty(x.Label, JObject.FromObject(new { analysis_type = x.Analysis, target_property = x.TargetProperty }))); var parmsJson = JsonConvert.SerializeObject(new JObject(jObs), Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmGroupBy, groupby); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); parms.Add(KeenConstants.QueryParmAnalyses, parmsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms); var result = new List <QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > > >(); foreach (JObject i in reply.Value <JArray>("result")) { var qgl = new List <QueryGroupValue <IDictionary <string, string> > >(); foreach (JObject o in i.Value <JArray>("value")) { var d = new Dictionary <string, string>(); string grpVal = ""; foreach (JProperty p in o.Values <JProperty>()) { if (p.Name == groupby) { grpVal = (string)p.Value; } else { d.Add(p.Name, (string)p.Value); } } qgl.Add(new QueryGroupValue <IDictionary <string, string> >(d, grpVal)); } var t = i.Value <JObject>("timeframe"); var qv = new QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > >(qgl, t.Value <DateTime>("start"), t.Value <DateTime>("end")); result.Add(qv); } return(result); }
/// <summary> /// Returns counts of resources in the event collection. /// Each item represents one interval. /// </summary> /// <param name="collection">Name of event collection to query</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<QueryIntervalValue<int>>> QueryCountIntervalAsync(string collection, QueryTimeframe timeframe, QueryInterval interval = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric<int>(KeenConstants.QueryCount, collection, "-", timeframe, interval, filters, timezone).ConfigureAwait(false); ; }
/// <summary> /// Gets a direct/deep-link URL to a specific KQL query in an Azure Application Insights resource. /// </summary> /// <param name="kqlQuery">The plain-text query.</param> /// <param name="tenantId">The Azure directory/tenant ID.</param> /// <param name="subscriptionId">The Azure Subscription ID.</param> /// <param name="resourceGroup">The Resource Group Nme.</param> /// <param name="appInsightsName">The Azure Application Insights resource name.</param> /// <param name="timeFrame">The Timeframe for the query.</param> /// <returns></returns> public static string GetApplicationInsightsDeepLink(string kqlQuery, string tenantId, string subscriptionId, string resourceGroup, string appInsightsName, QueryTimeframe timeFrame) { // Encode the query with our params. var encodedQuery = GetEncodedQuery(kqlQuery); // Return the URL with the query embedded, and put the timespan at the end. return($"https://portal.azure.com#@{tenantId}/blade/Microsoft_Azure_Monitoring_Logs/LogsBlade/resourceId/%2Fsubscriptions%2F{subscriptionId}%2FresourceGroups%2F{resourceGroup}%2Fproviders%2Fmicrosoft.insights%2Fcomponents%2F{appInsightsName}/source/LogsBlade.AnalyticsShareLinkToQuery/q/{encodedQuery}/timespan/{timeFrame}"); }
/// <summary> /// Returns counts of unique resources in the event collection. /// Each item contains information about the groupings in that interval. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="groupBy">Name of field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<int>>>>> QueryCountUniqueIntervalGroupAsync(string collection, string targetProperty, string groupBy, QueryTimeframe timeframe, QueryInterval interval, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric<int>(KeenConstants.QueryCountUnique, collection, targetProperty, groupBy, timeframe, interval, filters, timezone).ConfigureAwait(false); }
public async Task <T> Metric <T>(string metric, string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "") { if (string.IsNullOrWhiteSpace(collection)) { throw new ArgumentNullException("collection"); } if (string.IsNullOrWhiteSpace(targetProperty)) { throw new ArgumentNullException("targetProperty"); } var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty == "-" ? "" : targetProperty); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); var reply = await KeenWebApiRequest(metric, parms); T result; if ((reply.GetValue("result") is JArray) && (typeof(T) == (typeof(IEnumerable <string>)))) { // This is specifically to support SelectUnique which will call with T as IEnumerable<string> result = (T)(IEnumerable <string>)(reply.Value <JArray>("result").Values <string>()); } else { result = reply.Value <T>("result"); } return(result); }
/// <summary> /// Returns the minimum value for the target property in the event collection. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public string QueryMinimum(string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { try { return QueryMinimumAsync(collection, targetProperty, timeframe, filters, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
/// <summary> /// Extract full-form event data with all property values. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="latest">Request up to 100 of the most recent events added to a given collection.</param> /// <param name="email">If specified, email will be sent when the data is ready for download. Otherwise, it will be returned directly.</param> /// <returns></returns> public async Task<IEnumerable<dynamic>> QueryExtractResourceAsync(string collection,QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, int latest = 0, string email = "") { return await Queries.Extract(collection, timeframe, filters, latest, email).ConfigureAwait(false); }
/// <summary> /// Returns the minimum value for the target property in the event collection. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public IEnumerable<QueryIntervalValue<string>> QueryMinimumInterval(string collection, string targetProperty, QueryTimeframe timeframe, QueryInterval interval = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { try { return QueryMinimumIntervalAsync(collection, targetProperty, timeframe, interval, filters, timezone).Result; } catch (AggregateException ex) { throw ex.TryUnwrap(); } }
public async Task<IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<IDictionary<string, string>>>>>> MultiAnalysis(string collection, IEnumerable<MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable<QueryFilter> filters = null, string groupby = "", string timezone = "") { var jObs = analysisParams.Select(x => new JProperty(x.Label, JObject.FromObject(new { analysis_type = x.Analysis, target_property = x.TargetProperty }))); var parmsJson = JsonConvert.SerializeObject(new JObject(jObs), Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); var parms = new Dictionary<string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmGroupBy, groupby); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); parms.Add(KeenConstants.QueryParmAnalyses, parmsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms); var result = new List<QueryIntervalValue<IEnumerable<QueryGroupValue<IDictionary<string, string>>>>>(); foreach (JObject i in reply.Value<JArray>("result")) { var qgl = new List<QueryGroupValue<IDictionary<string, string>>>(); foreach (JObject o in i.Value<JArray>("value")) { var d = new Dictionary<string, string>(); string grpVal = ""; foreach (JProperty p in o.Values<JProperty>()) { if (p.Name == groupby) grpVal = (string)p.Value; else d.Add(p.Name, (string)p.Value); } qgl.Add( new QueryGroupValue<IDictionary<string, string>>(d, grpVal)); } var t = i.Value<JObject>("timeframe"); var qv = new QueryIntervalValue<IEnumerable<QueryGroupValue<IDictionary<string, string>>>>(qgl, t.Value<DateTime>("start"), t.Value<DateTime>("end")); result.Add(qv); } return result; }
/// <summary> /// Returns the maximum value for the target property. /// Each item represents one interval. /// </summary> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<QueryIntervalValue<string>>> QueryMaximumIntervalAsync(string collection,string targetProperty, QueryTimeframe timeframe, QueryInterval interval = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric<string>(KeenConstants.QueryMaximum, collection, targetProperty, timeframe, interval, filters, timezone).ConfigureAwait(false); }
/// <summary> /// Run a query returning a single value. /// </summary> /// <param name="queryType">Type of query to run.</param> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<string> QueryAsync(QueryType queryType, string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric(queryType, collection, targetProperty, timeframe, filters, timezone) .ConfigureAwait(false); }
/// <summary> /// Returns items collected by time interval and group. /// </summary> /// <param name="queryType">Type of query to run.</param> /// <param name="collection">Name of event collection to query.</param> /// <param name="targetProperty">Name of property to analyse.</param> /// <param name="groupBy">Name of field by which to group results.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param> /// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<IEnumerable<QueryIntervalValue<IEnumerable<QueryGroupValue<string>>>>> QueryIntervalGroupAsync (QueryType queryType, string collection, string targetProperty, string groupBy, QueryTimeframe timeframe, QueryInterval interval, IEnumerable<QueryFilter> filters = null, string timezone = "") { return await Queries.Metric(queryType, collection, targetProperty, groupBy, timeframe, interval, filters, timezone).ConfigureAwait(false); }
/// <summary> /// Funnels count relevant events in succession. See API documentation for details. /// </summary> /// <param name="steps">Analysis steps for funnel.</param> /// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param> /// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param> /// <returns></returns> public async Task<FunnelResult> QueryFunnelAsync(IEnumerable<FunnelStep> steps, QueryTimeframe timeframe = null, string timezone = "") { return await Queries.Funnel(steps, timeframe, timezone).ConfigureAwait(false); }
public async Task <IDictionary <string, string> > MultiAnalysis(string collection, IEnumerable <MultiAnalysisParam> analysisParams, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "") { var jObs = analysisParams.Select(x => new JProperty(x.Label, JObject.FromObject(new { analysis_type = x.Analysis, target_property = x.TargetProperty }))); var parmsJson = JsonConvert.SerializeObject(new JObject(jObs), Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); parms.Add(KeenConstants.QueryParmAnalyses, parmsJson); var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms); var result = new Dictionary <string, string>(); foreach (JProperty i in reply.Value <JObject>("result").Children()) { result.Add(i.Name, (string)i.Value); } return(result); }
public async Task <IEnumerable <QueryIntervalValue <T> > > Metric <T>(string metric, string collection, string targetProperty, QueryTimeframe timeframe, QueryInterval interval, IEnumerable <QueryFilter> filters = null, string timezone = "") { if (string.IsNullOrWhiteSpace(collection)) { throw new ArgumentNullException("collection"); } if (string.IsNullOrWhiteSpace(targetProperty)) { throw new ArgumentNullException("targetProperty"); } if (null == timeframe) { throw new ArgumentException("timeframe", "Timeframe must be specified for a series query."); } if (null == interval) { throw new ArgumentNullException("interval", "interval must be specified for a series query"); } var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty == "-" ? "" : targetProperty); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); var reply = await KeenWebApiRequest(metric, parms); IEnumerable <QueryIntervalValue <T> > result; if ((reply.GetValue("result") is JArray) && (typeof(T) == (typeof(IEnumerable <string>)))) { // This is specifically to support SelectUnique which will call with T as IEnumerable<string> result = from i in reply.Value <JArray>("result") let v = (T)i.Value <JArray>("value").Values <string>() let t = i.Value <JObject>("timeframe") select new QueryIntervalValue <T>(v, t.Value <DateTime>("start"), t.Value <DateTime>("end")); } else { result = from i in reply.Value <JArray>("result") let v = i.Value <T>("value") let t = i.Value <JObject>("timeframe") select new QueryIntervalValue <T>(v, t.Value <DateTime>("start"), t.Value <DateTime>("end")); } return(result); }
public async Task <string> Metric(QueryType queryType, string collection, string targetProperty, QueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "") { if (queryType == null) { throw new ArgumentNullException("queryType"); } if (string.IsNullOrWhiteSpace(collection)) { throw new ArgumentNullException("collection"); } if (string.IsNullOrWhiteSpace(targetProperty) && (queryType != QueryType.Count())) { throw new ArgumentNullException("targetProperty"); } var parms = new Dictionary <string, string>(); parms.Add(KeenConstants.QueryParmEventCollection, collection); parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty); parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString()); parms.Add(KeenConstants.QueryParmTimezone, timezone); parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString()); var reply = await KeenWebApiRequest(queryType.ToString(), parms); string result; if (queryType == QueryType.SelectUnique()) { // This is to support SelectUnique which is the only query type with a list-type result. result = string.Join(",", (reply.Value <JArray>("result").Values <string>())); } else { result = reply.Value <string>("result"); } return(result); }
/// <summary> /// Gets a direct/deep-link URL to a specific KQL query in an Azure Log Analytics workspace. /// </summary> /// <param name="kqlQuery">The plain-text query.</param> /// <param name="subscriptionId">The Azure Subscription ID.</param> /// <param name="resourceGroup">The Resource Group Nme.</param> /// <param name="workspaceId">The Log Analytics Workspace ID.</param> /// <param name="timeFrame">The Timeframe for the query.</param> /// <returns></returns> public static string GetLogAnalyticsDeepLink(string kqlQuery, string subscriptionId, string resourceGroup, string workspaceId, QueryTimeframe timeFrame) { // Encode the query with our params. var encodedQuery = GetEncodedQuery(kqlQuery); // Return the URL with the query embedded, and put the timespan at the end. return($"https://portal.azure.com/#blade/Microsoft_OperationsManagementSuite_Workspace/AnalyticsBlade/initiator/AnalyticsShareLinkToQuery/isQueryEditorVisible/true/scope/%7B%22resources%22%3A%5B%7B%22resourceId%22%3A%22%2Fsubscriptions%2F{subscriptionId}%2Fresourcegroups%2F{resourceGroup}%2Fproviders%2Fmicrosoft.operationalinsights%2Fworkspaces%2F{workspaceId}%22%7D%5D%7D/query/{encodedQuery}/isQueryBase64Compressed/true/timespanInIsoFormat/{timeFrame}"); }