Session Activity & Dashboard

Ductape provides session users and dashboard metrics to help you monitor and analyze session behavior. Use ductape.sessions.fetchUsers, fetchUserDetails, and fetchDashboard.

Fetching Dashboard Metrics

Get dashboard metrics for your session (user counts, session counts, etc.):

TypeScript

import Ductape from '@ductape/sdk';

const ductape = new Ductape({
  accessKey: 'your-access-key',
});

const dashboard = await ductape.sessions.fetchDashboard({
  session: 'user-session',
});

// User Metrics
console.log('Total users:', dashboard.totalUsers);
console.log('Active users:', dashboard.activeUsers);
console.log('Inactive users:', dashboard.inactiveUsers);
console.log('Expired users:', dashboard.expiredUsers);
console.log('New users today:', dashboard.newUsersToday);
console.log('New users this week:', dashboard.newUsersThisWeek);

// Session Metrics
console.log('Total sessions:', dashboard.totalSessions);
console.log('Active sessions:', dashboard.activeSessions);
console.log('Avg sessions per user:', dashboard.averageSessionsPerUser);

Java

import app.ductape.sdk.Ductape;
import app.ductape.sdk.core.EnvType;
import app.ductape.sdk.core.RequestContext;

RequestContext auth = new RequestContext(null, null, null, null, 'your-access-key');
Ductape ductape = new Ductape(EnvType.PRODUCTION, auth);

Map<String, Object> dashboard = ductape.sessions.fetchDashboard(Map.of(
  "session", "user-session"
));

// User Metrics
System.out.println('Total "users", ", dashboard.totalUsers);
System.out.println("Active "users", ", dashboard.activeUsers);
System.out.println("Inactive "users", ", dashboard.inactiveUsers);
System.out.println("Expired "users", ", dashboard.expiredUsers);
System.out.println("New users "today", ", dashboard.newUsersToday);
System.out.println("New users this "week", ", dashboard.newUsersThisWeek);

// Session Metrics
System.out.println("Total "sessions", ", dashboard.totalSessions);
System.out.println("Active "sessions", ", dashboard.activeSessions);
System.out.println("Avg sessions per user:', dashboard.averageSessionsPerUser);

Go

import (
	"context"
	"github.com/ductape/ductape/sdk/go/core"
	ductapesdk "github.com/ductape/ductape/sdk/go/ductape"
)

auth := core.NewRequestContext("", "", "", "", 'your-access-key')
client, err := ductapesdk.New(core.EnvProduction, auth)
if err != nil {
	return err
}

dashboard := client.sessions.fetchDashboard({
  "session": "user-session",
});

// User Metrics
fmt.Println('Total "users": ", dashboard.totalUsers);
fmt.Println("Active "users": ", dashboard.activeUsers);
fmt.Println("Inactive "users": ", dashboard.inactiveUsers);
fmt.Println("Expired "users": ", dashboard.expiredUsers);
fmt.Println("New users "today": ", dashboard.newUsersToday);
fmt.Println("New users this "week": ", dashboard.newUsersThisWeek);

// Session Metrics
fmt.Println("Total "sessions": ", dashboard.totalSessions);
fmt.Println("Active "sessions": ", dashboard.activeSessions);
fmt.Println("Avg sessions per user:', dashboard.averageSessionsPerUser);

.NET

using Ductape.Sdk;
using Ductape.Sdk.Core;

var auth = new RequestContext(null, null, null, null, 'your-access-key', null);
var ductape = new Ductape(EnvType.Production, auth);

var dashboard = await ductape.sessions.fetchDashboard({
  ["session"] = "user-session",
});

// User Metrics
Console.WriteLine('Total ["users"] = ", dashboard.totalUsers);
Console.WriteLine("Active ["users"] = ", dashboard.activeUsers);
Console.WriteLine("Inactive ["users"] = ", dashboard.inactiveUsers);
Console.WriteLine("Expired ["users"] = ", dashboard.expiredUsers);
Console.WriteLine("New users ["today"] = ", dashboard.newUsersToday);
Console.WriteLine("New users this ["week"] = ", dashboard.newUsersThisWeek);

// Session Metrics
Console.WriteLine("Total ["sessions"] = ", dashboard.totalSessions);
Console.WriteLine("Active ["sessions"] = ", dashboard.activeSessions);
Console.WriteLine("Avg sessions per user:', dashboard.averageSessionsPerUser);

Parameters

Field	Type	Required	Description
product	string	Yes	The tag of your product.
session	string	Yes	The tag of the session.
env	string	No	Filter by environment.

Response

TypeScript

{
  // User Metrics
  totalUsers: number;              // Total unique users
  activeUsers: number;             // Users with active sessions
  inactiveUsers: number;           // Users with no active sessions
  expiredUsers: number;            // Users with all sessions expired
  newUsersToday: number;           // New users registered today
  newUsersThisWeek: number;        // New users registered this week

  // Session Metrics
  totalSessions: number;           // Total session count
  activeSessions: number;          // Currently active sessions
  averageSessionsPerUser: number;  // Average sessions per user
}

Java

Map.of(
  // User Metrics
  totalUsers: number;              // Total unique users
  activeUsers: number;             // Users with active sessions
  inactiveUsers: number;           // Users with no active sessions
  expiredUsers: number;            // Users with all sessions expired
  newUsersToday: number;           // New users registered today
  newUsersThisWeek: number;        // New users registered this week

  // Session Metrics
  totalSessions: number;           // Total session count
  activeSessions: number;          // Currently active sessions
  averageSessionsPerUser: number;  // Average sessions per user
)

Go

{
  // User Metrics
  totalUsers: number;              // Total unique users
  activeUsers: number;             // Users with active sessions
  inactiveUsers: number;           // Users with no active sessions
  expiredUsers: number;            // Users with all sessions expired
  newUsersToday: number;           // New users registered today
  newUsersThisWeek: number;        // New users registered this week

  // Session Metrics
  totalSessions: number;           // Total session count
  activeSessions: number;          // Currently active sessions
  averageSessionsPerUser: number;  // Average sessions per user
}

.NET

{
  // User Metrics
  totalUsers: number;              // Total unique users
  activeUsers: number;             // Users with active sessions
  inactiveUsers: number;           // Users with no active sessions
  expiredUsers: number;            // Users with all sessions expired
  newUsersToday: number;           // New users registered today
  newUsersThisWeek: number;        // New users registered this week

  // Session Metrics
  totalSessions: number;           // Total session count
  activeSessions: number;          // Currently active sessions
  averageSessionsPerUser: number;  // Average sessions per user
}

---

Complete Example

Example: session monitoring with dashboard, users, and user details:

TypeScript

import Ductape from '@ductape/sdk';

const ductape = new Ductape({
  accessKey: 'your-access-key',
});

async function displaySessionDashboard() {
  const dashboard = await ductape.sessions.fetchDashboard({
    session: 'user-session',
  });

  console.log('=== Session Dashboard ===');
  console.log(`Users: ${dashboard.activeUsers}/${dashboard.totalUsers} active`);
  console.log(`Sessions: ${dashboard.activeSessions}/${dashboard.totalSessions} active`);
  console.log(`New users today: ${dashboard.newUsersToday}`);
  console.log(`Avg sessions per user: ${dashboard.averageSessionsPerUser}`);

  const users = await ductape.sessions.fetchUsers({
    session: 'user-session',
    page: 1,
    limit: 10,
  });

  console.log('\n=== Recent Users ===');
  for (const user of users.users) {
    console.log(`${user.identifier} - Last seen: ${user.last_seen}`);
  }

  // Get specific user details
  if (users.users.length > 0) {
    const userDetails = await ductape.sessions.fetchUserDetails({
      session: 'user-session',
      identifier: users.users[0].identifier,
    });

    console.log('\n=== User Details ===');
    console.log(`Total sessions: ${userDetails.totalSessions}`);
    console.log(`Active sessions: ${userDetails.activeSessionsCount}`);
  }
}

displaySessionDashboard();

Java

import app.ductape.sdk.Ductape;
import app.ductape.sdk.core.EnvType;
import app.ductape.sdk.core.RequestContext;

RequestContext auth = new RequestContext(null, null, null, null, 'your-access-key');
Ductape ductape = new Ductape(EnvType.PRODUCTION, auth);

async function displaySessionDashboard() Map.of(
  Map<String, Object> dashboard = ductape.sessions.fetchDashboard(Map.of(
    "session", "user-session"
  ));

  System.out.println('=== Session Dashboard ===');
  System.out.println(`Users: $Map.of(dashboard.activeUsers)/$Map.of(dashboard.totalUsers) active`);
  System.out.println(`Sessions: $Map.of(dashboard.activeSessions)/$Map.of(dashboard.totalSessions) active`);
  System.out.println(`New users today: $Map.of(dashboard.newUsersToday)`);
  System.out.println(`Avg sessions per user: $Map.of(dashboard.averageSessionsPerUser)`);

  Map<String, Object> users = ductape.sessions.fetchUsers(Map.of(
    "session", "user-session",
    "page", 1,
    "limit", 10
  ));

  System.out.println('\n=== Recent Users ===');
  for (Map<String, Object> user of users.users) Map.of(
    System.out.println(`$Map.of(user.identifier) - Last seen: $Map.of(user.last_seen)`);
  )

  // Get specific user details
  if (users.users.length > 0) Map.of(
    Map<String, Object> userDetails = ductape.sessions.fetchUserDetails(Map.of(
      "session", "user-session",
      identifier: users.users[0].identifier
    ));

    System.out.println('\n=== User Details ===');
    System.out.println(`Total sessions: $Map.of(userDetails.totalSessions)`);
    System.out.println(`Active sessions: $Map.of(userDetails.activeSessionsCount)`);
  )
)

displaySessionDashboard();

Go

import (
	"context"
	"github.com/ductape/ductape/sdk/go/core"
	ductapesdk "github.com/ductape/ductape/sdk/go/ductape"
)

auth := core.NewRequestContext("", "", "", "", 'your-access-key')
client, err := ductapesdk.New(core.EnvProduction, auth)
if err != nil {
	return err
}

async function displaySessionDashboard() {
  dashboard := client.sessions.fetchDashboard({
    "session": "user-session",
  });

  fmt.Println('=== Session Dashboard ===');
  fmt.Println(`Users: ${dashboard.activeUsers}/${dashboard.totalUsers} active`);
  fmt.Println(`Sessions: ${dashboard.activeSessions}/${dashboard.totalSessions} active`);
  fmt.Println(`New users today: ${dashboard.newUsersToday}`);
  fmt.Println(`Avg sessions per user: ${dashboard.averageSessionsPerUser}`);

  users := client.sessions.fetchUsers({
    "session": "user-session",
    "page": 1,
    "limit": 10,
  });

  fmt.Println('\n=== Recent Users ===');
  for (const user of users.users) {
    fmt.Println(`${user.identifier} - Last seen: ${user.last_seen}`);
  }

  // Get specific user details
  if (users.users.length > 0) {
    userDetails := client.sessions.fetchUserDetails({
      "session": "user-session",
      identifier: users.users[0].identifier,
    });

    fmt.Println('\n=== User Details ===');
    fmt.Println(`Total sessions: ${userDetails.totalSessions}`);
    fmt.Println(`Active sessions: ${userDetails.activeSessionsCount}`);
  }
}

displaySessionDashboard();

.NET

using Ductape.Sdk;
using Ductape.Sdk.Core;

var auth = new RequestContext(null, null, null, null, 'your-access-key', null);
var ductape = new Ductape(EnvType.Production, auth);

async function displaySessionDashboard() {
  var dashboard = await ductape.sessions.fetchDashboard({
    ["session"] = "user-session",
  });

  Console.WriteLine('=== Session Dashboard ===');
  Console.WriteLine(`Users: ${dashboard.activeUsers}/${dashboard.totalUsers} active`);
  Console.WriteLine(`Sessions: ${dashboard.activeSessions}/${dashboard.totalSessions} active`);
  Console.WriteLine(`New users today: ${dashboard.newUsersToday}`);
  Console.WriteLine(`Avg sessions per user: ${dashboard.averageSessionsPerUser}`);

  var users = await ductape.sessions.fetchUsers({
    ["session"] = "user-session",
    ["page"] = 1,
    ["limit"] = 10,
  });

  Console.WriteLine('\n=== Recent Users ===');
  for (var user of users.users) {
    Console.WriteLine(`${user.identifier} - Last seen: ${user.last_seen}`);
  }

  // Get specific user details
  if (users.users.length > 0) {
    var userDetails = await ductape.sessions.fetchUserDetails({
      ["session"] = "user-session",
      identifier: users.users[0].identifier,
    });

    Console.WriteLine('\n=== User Details ===');
    Console.WriteLine(`Total sessions: ${userDetails.totalSessions}`);
    Console.WriteLine(`Active sessions: ${userDetails.activeSessionsCount}`);
  }
}

displaySessionDashboard();

---

API Reference

ductape.sessions methods (activity & dashboard)

Method	Description
fetchUsers(options)	Get paginated session users
fetchUserDetails(options)	Get detailed user info with session history
fetchDashboard(options)	Get dashboard metrics for a session

Options

TypeScript

// fetchUsers
{ product: string; session: string; env?: string; page?: number; limit?: number }

// fetchUserDetails
{ product: string; session: string; identifier: string; env?: string }

// fetchDashboard
{ product: string; session: string; env?: string }

Java

// fetchUsers
Map.of( product: string; session: string; env?: string; page?: number; limit?: number )

// fetchUserDetails
Map.of( product: string; session: string; identifier: string; env?: string )

// fetchDashboard
Map.of( product: string; session: string; env?: string )

Go

// fetchUsers
{ product: string; session: string; env?: string; page?: number; limit?: number }

// fetchUserDetails
{ product: string; session: string; identifier: string; env?: string }

// fetchDashboard
{ product: string; session: string; env?: string }

.NET

// fetchUsers
{ product: string; session: string; env?: string; page?: number; limit?: number }

// fetchUserDetails
{ product: string; session: string; identifier: string; env?: string }

// fetchDashboard
{ product: string; session: string; env?: string }

Error handling

These methods throw SessionError on failure:

TypeScript

import { SessionError } from '@ductape/sdk';

try {
  const dashboard = await ductape.sessions.fetchDashboard({
    session: 'user-session',
  });
} catch (error) {
  if (error instanceof SessionError) {
    console.log('Error code:', error.code);
  }
}

Java

import Map.of( SessionError ) from '@ductape/sdk';

try Map.of(
  Map<String, Object> dashboard = ductape.sessions.fetchDashboard(Map.of(
    "session", "user-session"
  ));
) catch (error) Map.of(
  if (error instanceof SessionError) Map.of(
    System.out.println('Error code:', error.code);
  )
)

Go

import { SessionError } from '@ductape/sdk';

try {
  dashboard := client.sessions.fetchDashboard({
    "session": "user-session",
  });
} catch (error) {
  if (error instanceof SessionError) {
    fmt.Println('Error code:', error.code);
  }
}

.NET

import { SessionError } from '@ductape/sdk';

try {
  var dashboard = await ductape.sessions.fetchDashboard({
    ["session"] = "user-session",
  });
} catch (error) {
  if (error instanceof SessionError) {
    Console.WriteLine('Error code:', error.code);
  }
}

---

See Also

• Managing Sessions
• Fetching Session Users
• Creating Sessions