Sign up to receive free email alerts when patent applications with chosen keywords are publishedSIGN UP

Abstract:

A method for testing a new feature of an online gaming application is
provided. The method initiates with assigning each of a plurality of
users to one of a test group and a control group. Each of the test group
users is provided a gaming application including a new game feature
enabled, and each of the control group users is provided the gaming
application without the new game feature enabled. Gaming activity and
social network activity of the test group users is evaluated to generate
an evaluation score for the test group users. Gaming activity and social
network activity of the control group users is evaluated to generate an
evaluation score for the control group users.

Claims:

1. A processor-implemented method for testing a new feature of an online
gaming application, comprising: assigning each of a plurality of users to
one of a test group and a control group; providing each of the test group
users a gaming application including a new game feature enabled;
providing each of the control group users the gaming application without
the new game feature enabled; evaluating gaming activity and social
network activity of the test group users to generate an evaluation score
for the test group users; evaluating gaming activity and social network
activity of the control group users to generate an evaluation score for
the control group users.

2. The method of claim 1, wherein evaluating gaming activity includes
detecting one or more of messages, requests, invitations, gift
transactions, object transactions, and currency transactions.

3. The method of claim 1, wherein evaluating social network activity
includes detecting one or more of sent messages, received messages,
invitations, and requests.

4. The method of claim 1, wherein evaluating gaming activity includes
tracking a number of game actions taking place between each of the
plurality of users and the gaming application.

5. The method of claim 1, wherein evaluating gaming activity includes
tracking content of customer service requests related to the gaming
application.

6. The method of claim 1, further comprising, generating a report
comparing the evaluation scores of the test group users and the control
group users.

7. A system for testing a new feature of an online gaming application,
comprising: a memory; and a processor disposed in communication with the
memory and configured to issue processing instructions stored in the
memory, wherein the processor issues instructions to: assign each of a
plurality of users to one of a test group and a control group; provide
each of the test group users a gaming application including a new game
feature enabled; provide each of the control group users the gaming
application without the new game feature enabled; evaluate gaming
activity and social network activity of the test group users to generate
an evaluation score for the test group users; evaluate gaming activity
and social network activity of the control group users to generate an
evaluation score for the control group users.

8. The system of claim 7, wherein evaluating gaming activity includes
detecting one or more of messages, requests, invitations, gift
transactions, object transactions, and currency transactions.

9. The system of claim 7, wherein evaluating social network activity
includes detecting one or more of sent messages, received messages,
invitations, and requests.

10. The system of claim 7, wherein evaluating gaming activity includes
tracking a number of game actions taking place between each of the
plurality of users and the gaming application.

11. The system of claim 7, wherein evaluating gaming activity includes
tracking content of customer service requests related to the gaming
application.

12. The system of claim 1, wherein the processor further issues
instructions to: generate a report comparing the evaluation scores of the
test group users and the control group users.

13. A processor-readable tangible medium storing processor-issuable
online game testing instructions to: assign each of a plurality of users
to one of a test group and a control group; provide each of the test
group users a gaming application including a new game feature enabled;
provide each of the control group users the gaming application without
the new game feature enabled; evaluate gaming activity and social network
activity of the test group users to generate an evaluation score for the
test group users; evaluate gaming activity and social network activity of
the control group users to generate an evaluation score for the control
group users.

14. The medium of claim 13, wherein evaluating gaming activity includes
detecting one or more of messages, requests, invitations, gift
transactions, object transactions, and currency transactions.

15. The medium of claim 13, wherein evaluating social network activity
includes detecting one or more of sent messages, received messages,
invitations, and requests.

16. The medium of claim 13, wherein evaluating gaming activity includes
tracking a number of game actions taking place between each of the
plurality of users and the gaming application.

17. The medium of claim 13, wherein evaluating gaming activity includes
tracking content of customer service requests related to the gaming
application.

18. The medium of claim 13, the medium further storing instructions to:
generate a report comparing the evaluation scores of the test group users
and the control group users.

[0004] The entire contents of the aforementioned applications are herein
expressly incorporated by reference.

FIELD

[0005] The present invention is directed generally to apparatuses,
methods, and systems for user online behavior monitoring, and more
particularly, to APPARATUSES, METHODS AND SYSTEMS FOR A LIVE ONLINE GAME
TESTER.

BACKGROUND

[0006] Users may interact online with each other using Internet
social-gaming applications. Services like social networks allow users to
connect and communicate with one another. Such services also allow users
to play games with others online. Users impart a great amount of
sensitive information in such social networks.

[0008] In one embodiment, to process a virtual security clearance request,
the OBM may obtain user online gaming pattern data including gaming
actions and their associated timestamps, user online social activities
and their associated timestamps; and virtual security clearance
evaluation rules. The OBM may generate a social-gaming activity timeline
using the gaming actions, social activities and timestamps. By applying
the virtual security clearance evaluation rules to the social-gaming
activity timeline, the OBM may calculate evaluation scores. The OBM may
compare the evaluation scores to the evaluation score thresholds to
generate virtual security clearance flags, and may determine whether any
virtual security clearance flags were generated based on the comparison.
The OBM may, upon determining that no virtual security clearance flags
were generated, obtain user online gaming action input and user gaming
environment data, and generate updated user gaming environment data using
the user online gaming action input.

[0009] In one embodiment, upon receiving a customer service request from a
user, the OBM may obtain, for processing the customer service request,
user social graph data identifying co-users, social networking action
identifiers and associated social networking action timestamps; user
online gaming action identifiers and associated gaming action timestamps;
and customer service request evaluation rules and associated request
evaluation score thresholds. The OBM may generate social-gaming activity
timelines for the user and the co-users using the gaming action
identifiers, social networking action identifiers and timestamps. The OBM
may generate a social-gaming activity thread for the user using the
social-gaming activity timelines. The OBM may calculate customer service
request evaluation rule scores by applying the customer service request
evaluation rules to the social-gaming activity thread, and compare each
customer service request evaluation rule score to its associated request
evaluation score threshold to generate request evaluation flags. The OBM
may determine whether to process the customer service request based on
whether any request evaluation flags were generated.

[0010] In one embodiment, the OBM may provide, in response to a gaming app
request from a user, a gaming app including a test game feature for the
user. The OBM may obtain user social graph data identifying co-users of
the user. The OBM may also obtain: online gaming pattern data for the
users and the co-users, including gaming action identifiers and their
associated gaming action timestamps; user online social activity data,
for the users and the co-users, including social networking action
identifiers and their associated social networking action timestamps; and
game feature adoption evaluation instructions. The OBM may generate
social-gaming activity timelines for the users and the co-users using the
gaming action identifiers and the associated gaming action timestamps, as
well as the social networking action identifiers and the associated
social networking action timestamps. The OBM may also calculate and
provide game feature adoption scores by applying the game feature
adoption evaluation instructions to the generated social-gaming activity
timelines.

[0011] In one embodiment, the OBM may generate individual social-gaming
activity timelines for a group of users within a geographical region
using user online gaming pattern and social activity data. The OBM may
calculate individual time-varying activity level graphs for the users, as
well as an aggregate activity level graph. The OBM may identify an
activity trough in the aggregate activity level graph, and an event in
the geographical region corresponding to the activity level trough. Based
on keywords corresponding to the event, the OBM may obtain product
results from a product database. The OBM may identify a subset of the
users whose individual time-varying activity level graphs include an
activity level trough during the activity level trough in the aggregate
activity level graph, and may provide an advertisement for a product from
the product results for the identified subset of the users.

[0013] FIG. 1 is of a block diagram illustrating example aspects of a
virtual security camera in some embodiments of the OBM;

[0014] FIG. 2 is of a block diagram illustrating example aspects of a
customer service request evaluator in some embodiments of the OBM;

[0015] FIG. 3 is of a block diagram illustrating example aspects of a live
online game tester in some embodiments of the OBM;

[0016] FIG. 4 is of a block diagram illustrating example aspects of an
engagement-tracking game modifier in some embodiments of the OBM;

[0017] FIG. 5 is of a block diagram illustrating examples of suspicious
user online gaming behavior in some embodiments of the OBM;

[0018] FIGS. 6A-B are of block diagrams illustrating examples of
suspicious user online social behavior in some embodiments of the OBM;

[0019] FIG. 7 is of a data flow diagram illustrating example aspects of
initiating a user gaming session with the OBM in some embodiments of the
OBM;

[0020] FIGS. 8A-B are of logic flow diagrams illustrating example aspects
of initiating a user gaming session with the OBM in some embodiments of
the OBM, e.g., a gaming session initiation ("GSI") component;

[0021] FIGS. 9A-B are of data flow diagrams illustrating example aspects
of implementing user gaming interactions with the OBM within a user
gaming session in some embodiments of the OBM;

[0022] FIGS. 10A-C are of logic flow diagrams illustrating example aspects
of implementing user gaming interactions with the OBM within a user
gaming session in some embodiments of the OBM, e.g., a user gaming
interaction ("UGI") component;

[0023] FIGS. 11A-B are of data flow diagrams illustrating example aspects
of evaluating a user's online social and/or gaming behavior in some
embodiments of the OBM;

[0024] FIGS. 12A-E are of logic flow diagrams illustrating example aspects
of evaluating a user's online social and/or gaming behavior in some
embodiments of the OBM, e.g., a social gaming behavior evaluation
("SGBE") component;

[0025] FIG. 13 is of a logic flow diagram illustrating example aspects of
terminating a user gaming session with the OBM in some embodiments of the
OBM, e.g., a gaming session termination ("GST") component;

[0026] FIG. 14 is of a table illustrating example evaluation rules for
implementing a virtual security camera using the OBM in some embodiments
of the OBM;

[0027] FIG. 15 is of a logic flow diagram illustrating example aspects of
implementing a virtual security camera for gaming within the OBM in some
embodiments of the OBM, e.g., a virtual security camera ("VSC")
component;

[0028] FIG. 16 is of a table illustrating example evaluation rules for
implementing a customer service request evaluator using the OBM in some
embodiments of the OBM;

[0029] FIG. 17 is of a logic flow diagram illustrating example aspects of
implementing a customer service request evaluator within the OBM in some
embodiments of the OBM, e.g., a customer service request evaluator
("CSRE") component;

[0030] FIGS. 18A-B are of block diagrams illustrating example aspects of
customer service request management in some embodiments of the OBM;

[0031] FIGS. 19A-B are of logic flow diagrams illustrating example aspects
of implementing live testing of online games within the OBM in some
embodiments of the OBM, e.g., a live online game tester ("LOGT")
component;

[0032] FIG. 20 is of a logic flow diagram illustrating example aspects of
implementing live testing of a set of online game features within the OBM
in some embodiments of the OBM, e.g., a game feature set tester ("GFST")
component;

[0033] FIGS. 21A-B are of logic flow diagrams illustrating example aspects
of implementing strategic game modification based on tracking engagement
of a single user within the OBM in some embodiments of the OBM, e.g., a
user engagement-tracking game modification ("U-ETGM") component;

[0034] FIGS. 22A-C are of logic flow diagrams illustrating example aspects
of implementing strategic game modification based on tracking engagement
of a group of users within the OBM in some embodiments of the OBM, e.g.,
a group engagement-tracking game modification ("G-ETGM") component; and

[0035] FIG. 23 is of a block diagram illustrating embodiments of the OBM
controller.

[0036] The leading number of each reference number within the drawings
indicates the figure in which that reference number is introduced and/or
detailed. As such, a detailed discussion of reference number 101 would be
found and/or introduced in FIG. 1. Reference number 201 is introduced in
FIG. 2, etc.

DETAILED DESCRIPTION

[0037] Users exhibit identifiable behavioral characteristics using
Internet social-gaming applications. The user behavioral characteristics
in Internet social-gaming applications may be affected by the
characteristics of the virtual social-gaming environment and the personal
characteristics of the users.

Online Behavior Monitor

OBM

[0038] FIG. 1 is of a block diagram illustrating example aspects of a
virtual security camera in some embodiments of the OBM. In some
implementations a virtual security camera may monitor the online social
and/or gaming activities of users associated with each other via a social
graph of a social networking application 103a and/or an online gaming
application 103b. For example, the virtual security camera may monitor
the social-gaming activities of the users for suspicious activity. For
example, a user may send/receive a message 102a, a request 102b, and/or
an invitation 102C to another user over a social networking application
103a and a virtual security camera 105 may monitor the request, message,
invitation, and/or the like, for suspicious activity and/or behavior.
Similarly, in some implementations, a user may be active via an online
gaming application 103b by sending/receiving game actions 102e, customer
service requests 102f, gift, object, currency transactions 102d, and/or
the like. In such implementations, a virtual security camera 105 may
assess activity of the user and associated users for suspicious activity
and/or behavior.

[0039] FIG. 2 is of a block diagram illustrating example aspects of a
customer service request evaluator in some embodiments of the OBM. In
some implementations a customer service request evaluator 205 may monitor
the social activity of various users of a social networking application
103a and/or an online gaming application 103b to determine if a user's
201a customer service request 202e is legitimate and/or if the user 201a
can be trusted 204a. For example, the customer service request evaluator
205 may determine if the user 201a can be trusted based on the user's
observed social activity and/or behavior. For example, a user may
send/receive a message 202a, a request 202b, and/or an invitation 202c to
another user over a social networking application 203a and a customer
service request evaluator 205 may monitor the request, message,
invitation, and/or the like, in accordance to the user's customer service
request 202e. Similarly, in other implementations, a user 201a may be
active via an online gaming application 203b by sending/receiving game
actions 202e, gift, object, currency transactions 202d, and/or the like.
In such implementations, a customer service request evaluator 205 may
assess the user 201a, the user's activity and associated users (e.g, user
201d, user 201b, etc.) in accordance to the user's customer service
request 202e. In other implementations a customer service request
evaluator 205 may determine how important a user is 204b, and/or how a
user's customer service request 202e should be prioritized 204b based on
the user's observed social activity and/or behavior.

[0040] FIG. 3 is of a block diagram illustrating example aspects of a live
online game tester in some embodiments of the OBM. In some
implementations a developer 306 may wish to introduce a new game feature
302g to an online gaming application 303b and a Live online game tester
305 may observe user activity associated with the online gaming
application 304, social networking application 303a, and between one
another. In some implementations the Live online game tester 305 may
observe what a new game feature 302g allows a user to do. In some
implementations the Live online game tester 305 may analyze user activity
(e.g., messages, requests, invitations, gift, object, currency
transactions, games actions, customer service, request, etc.) for
interesting feedback and/or user behavior 304. For example, a user may
increase the number of invitations 302c made to other users 301d via a
social network application 303a, or, in other examples, a user may
increase the number of messages 302a sent to another 301b user regarding
the online gaming application 303b after a new game feature's
introduction 302g. In some implementations the live online game tester
305 may analyze the impact 304 of the new game feature 302g on the online
gaming application 303b. For example the Live online game tester 305 may
observe an increase in game actions has taken place between users and an
online gaming application 303b since the new game feature's introduction
302g. In another example, the Live online game tester 305 may determine
if the content of a customer service requests 302f to an online game
application 303b has changed with respect to, for example, historical
customer service requests. In some implementations the Live online game
tester 305 may observe social networking application activity between
users comprising sent/received messages, invitations, requests, etc.
related to the introduced new game feature.

[0041] FIG. 4 is of a block diagram illustrating example aspects of an
engagement-tracking game modifier in some embodiments of the OBM. In some
implementations an engagement tracking game modifier 405 may monitor a
user 401a and user's activity with an online gaming application 403b to
determine if the user is having trouble with a game or losing interest in
a game and may create incentives for other users, associated with the
user, to help said user 404. For example, an engagement tracking game
modifier 405 may determine user 401a is having trouble with a game by
monitoring the user's interactions with the online gaming application
and/or social activity with users 401b, users 401c, and user 401d. The
engagement tracking game modifier 405 may create and provide incentives
to user 401b, user 401c, and user 401d, according to each user's
monitored social activity history, relationship with the user 401a,
and/or activity with the online gaming application. In some
implementations incentives may include credits, discounts, rewards,
prizes, game hints, secret game codes, and/or the like. For example, an
engagement tracking game modifier 405 may offer entry into a game at a
discounted rate to users associated with a user 401a having difficulty
with a game. In some implementations the engagement tracking game
modifier 405 may provide additional incentives to the assisting users
once they've successfully helped the user 401a. For example, users may be
offered a discount on future online gaming application 403b items once
they succeed in helping the user 401a resolve his/her difficulty (e.g.,
defeating a dragon, building a city, finding a treasure chest, etc.).

[0042] FIG. 5 is of a block diagram illustrating examples of suspicious
user online gaming behavior in some embodiments of the OBM. Some examples
of suspicious online gaming behavior may include in-game collusions 500a
or preplanned collusions 500b. In in-game collusions a number of users
collaborate while an adversarial online game is in progress 505a. These
users may communicate with one another in a variety of ways, one way
including sending messages 506a to one another. The nature of these
messages may be monitored by some embodiments of the OBM to determine
suspicious behavior. For example out of a number of users involved in an
adversarial game (e.g., poker) a user 504s may send a message 506a to
user 503a describing sensitive/privileged information (e.g., poker hand).
In another example, a user 504a may propose to user 504a a deal of some
kind, one that may for example be used to leverage against the excluded
users (e.g., user 501a, user 502a, etc.). In some other implementations,
the instance of a kind of messaging 506a between one or more users
involved in an adversarial online game may be monitored by some
embodiments of the OBM and determined to be suspicious and/or classified
as in-game collusion 500a. In some implementations, preplanned collusions
include a user or group of users that produce self-sacrificing game
inputs during an adversarial online game 505b. For example a user 503b
may participate in a game 505b and enter game inputs 506b that instantly
and/or consecutively damage the winning potential of the user 503b and
may or may not enhance the winning probability of another user (e.g.,
user 501b, user 502b, user 504b, etc.). In another example, a user 503b
enters a poker game 505b with a significant pot and bets the entire pot
on a statistically weak hand 506b. Some implementations may monitor this
input 506b by the user 503b and instantly classify the act as suspicious.

[0043] FIGS. 6A-B are of block diagrams illustrating examples of
suspicious user online social behavior in some embodiments of the OBM. In
FIG. 6A each node represents a social network user, each line represents
a relationship between a user and another user, and each arrow represents
an open or closed social loop which includes a transaction (e.g., money,
gift, favor, friend gesture, and/or the like). The direction of the arrow
shows a direction of a transaction (e.g., a gift sent from a user and
received by another user, etc.). An closed social loop includes one
arrow, whereas a open social loop includes two arrows in opposing
directions.

[0044] In some implementations examples of suspicious user online social
behavior may be represented by a social graph or a transaction graph.
More suspicious user online social behavior, shown in some examples by a
shallow social graph 601a, may include a user with numerous friends where
none of the user's friends have a relationship with one another. In
contrast, a cohesive social graph exemplifies less suspicious online
social behavior and shows a user with numerous friends, all of whom
possess some relationship with another. For example, a user's friends may
belong to similar groups, exchange messages with another, and/or the
like. In these examples a user's friends may be connected with one
another by various degrees of separation. In other implementations, the
number of interconnected relationships between a user and a user's
friends may affect the level of suspicion associated with the user's
online social behavior. In other implementations the types of
relationships between a user and/or user's friends may affect the level
of suspicion associated with the user.

[0045] In other implementations examples of more suspicious user online
social behavior may be shown in a broken-loop transaction graph 602a. In
a broken-loop transaction graph 602a a user is on the receiving end of
multiple closed social loops. For example, a highly suspicious example of
user online behavior may include a user receiving dozens of gift
transactions from other various users. Further to the previous example,
in other implementations, a user's online social behavior may be even
more suspicious if none of the users sending a gift to the user have a
relationship with one another 601a. In contrast, a looped transaction
graph 602b shows less suspicious user online social behavior. In a looped
transaction graph 602b a user may be involved in numerous open social
loops. For example, a user may receive various favors from other users
and in response may send gifts and/or friend gestures to each one of
those users. Some of these graphs may be discerned by examining users'
friend lists and building link topologies/graphs. In one embodiment, a
users' direct friends may be traversed to discern if they each in turn
have additional friends. Friends that do not further have their own
friends may then be counted as having negative values (e.g., -1), while
friends that in turn have friends, and in turn have other friends, may be
given positive values (e.g., +1) for each recurring leg. A total count
may be developed, and thresholds (e.g., total values greater than 0) may
be used to mark a graph as suspicious.

[0046] In FIG. 6B suspicious social behavior examples are shown according
to a user's location according to a gaming/social networking service, a
user's social activity. For example, in a less suspicious example a user
may transmit a number of messages to a social networking service, one of
which indicating they are leaving for Europe in a few days 603a. After a
few days 606b, the user accesses the social network through a server in
Europe 608a and submits an image of themselves to the social network
service 604a. In other implementations more suspicious social behavior
may include abrupt and/or unannounced changes in a user's social activity
patterns. For example, a user may access a social networking service in
South America 607b at 3 PM Pacific Standard Time 606a and then, at 6 PM
Pacific Standard Time 606c, the user accesses the social network in
another part of the world (e.g., Australia, etc.).

[0047] FIG. 7 is of a data flow diagram illustrating example aspects of
initiating a user gaming session with the OBM in some embodiments of the
OBM. In some implementations, a user 701 may wish to interact with a
social gaming network, e.g., OBM. The user may utilize a client device,
e.g., 702, to interact with the social gaming network. For example, the
user may provide input, e.g., 721 into the client device. In various
implementations, the user input may include, but not be limited to:
keyboard entry, mouse clicks, depressing buttons on a joystick/game
console, voice commands, single/multi-touch gestures on a touch-sensitive
interface, touching user interface elements on a touch-sensitive display,
and/or the like. The client may communicate with the social gaming
network, and may provide output, e.g., 729 for the user. For example, the
client may provide output including, but not limited to: sounds, music,
audio, video, images, tactile feedback, vibration alerts (e.g., on
vibration-capable client devices such as a smartphone etc.), and/or the
like.

[0048] In some implementations, the user may provide input, e.g., 721, to
the client device indicating that the user desires to utilize an
application (e.g., a game) provided by the social gaming network. In
response, the client may generate a gaming app request, and provide the
gaming app request, e.g., 722 to an OBM server, e.g., gaming server 703a.
For example, a browser application executing on the client may provide,
on behalf of the user, a (Secure) Hypertext Transfer Protocol ("HTTP(S)")
GET message for a HyperText Markup Language ("HTML") page, wherein the
HTML page includes JavaScript® commands to embed an Adobe® Flash
object including an application for the user in the HTML page. An
exemplary HTTP(S) GET message that may be provided by a browser executing
on the client to request an HTML page is provided below:

[0049] In response to the app request, the OBM may identify a gaming
server to which to redirect the gaming app request received from the
client. Upon identifying the gaming server to process the user's request,
the OBM may provide a user session request to the identified gaming
server. For example, the server receiving the user app request may
provide a HTTP(S) POST message requesting acknowledgment from the
identified gaming server that it will process the user's gaming app
request. For example, the HTTP(S) POST message may include in its message
body the user ID, client IP address etc., and a request for user session
acknowledgment. An exemplary user session request HTTP(S) POST message,
including user session request details encoded in the eXtensible Markup
Language ("XML") format, is provided below:

[0051] In some implementations, upon receiving the gaming server's user
session acknowledgment, the server receiving the user's app request may
provide a URL redirection message to the client. The URL redirection
message may include a Uniform Resource Locator ("URL") of the identified
gaming server, and may indicate to the client that the client redirect
the gaming app request to the identified gaming server. For example, with
reference to the exemplary HTTP(S) GET gaming app request message
provided by the client, the load balancing server may respond by
providing a HTTP(S) REDIRECT 300 message, similar to the exemplary
message provided below:

[0052] Upon receiving the URL redirection message, the client may provide
the gaming app request 722 (e.g., similar to the gaming app request first
sent to the OBM) to the identified gaming server. In response the gaming
server may generate a gaming app query (e.g., 723) for a gaming app,
e.g., 725, and provide the gaming app query (e.g., 724) to a game
database, e.g., 704a. In response, the game database may provide the
gaming app (e.g., an Adobe® Flash object) to the gaming server. For
example, the gaming server may execute a PHP script including SQL
commands to query the game database and obtain the gaming app. An
exemplary listing, written substantially in the form of PHP/SQL commands,
illustrating substantive aspects of querying the game database for the
gaming app is provided below:

[0053] In some implementations, the gaming server may create a new
instance of a user session, e.g., 726, for the user utilizing the app
(e.g., create a data structure in memory storing a game state of the app
for the user), and store the initialized user state data structure in the
gaming environment database, e.g., 727. The gaming server may then
provide the client with the app, e.g., 728, for presentation to the user.
For example, the gaming server may provide a HTML page including a
reference to an Adobe® Flash object (including a user application,
e.g., 728) stored on the gaming server. An exemplary HTML code listing
including JavaScript® commands referencing an Adobe® Flash object
within the HTML page is provided below:

[0054] Upon obtaining the app, the client device may execute the app for
presentation to the user, e.g., 729. For example, with reference to the
examples above, a web browser executing on the client device may render
the HTML web page and may communicate with the gaming server to download
the Adobe® Flash object. An Adobe® Flash browser plug-in
installed on the client device and operating in conjunction with the
browser may play/execute the downloaded Flash object for presentation to
the user.

[0055] FIGS. 8A-B are of logic flow diagrams illustrating example aspects
of initiating a user gaming session with the OBM in some embodiments of
the OBM, e.g., a gaming session initiation ("GSI") component 800. In some
implementations, a user and/or client may generate a request, e.g., 801,
to join a multi-user network application (e.g., a massively multiplayer
online game). The client may provide the generated request 802 for an app
for a server (e.g., gaming server). For example, a web browser executing
on the client may provide a HTTP(S) GET message requesting a HTML page
including JavaScript® commands to embed an Adobe® Flash object
including the application for the user in the HTML page, as illustrated
in the example provided with reference to FIG. 7. The server receiving
the app request may determine that user credentials are required in order
to determine whether the user is authenticated to use the app. The server
may provide a mechanism for the user to provide the requested
credentials. For example, in some implementations, the server may provide
an HTML page with an input form for the user to provide user credentials,
and request user credentials. The user may input the user credentials
into the HTML input form, and press a submit button included in the HTML
form. Upon pressing the submit button, the web browser of the client
device may generate a HTTP(S) POST message including the user-provided
form inputs for the server. As another example, in some implementations,
the server may provide an Adobe® Flash object including
ActionScript® 3.0 commands to request the user to provide user
credentials by entering the credentials into input text fields included
in the Adobe® Flash object, and may provide the user-entered
credentials for a server via a HTTP(S) POST message to the server.

[0056] Upon obtaining the user credentials, the server may query a user
profile database to determine whether the user is authenticated to use
the app. For example, the server may implement a PHP script including
commands to query a user profile database for user authentication
details, and may compare the authentication details obtained via querying
the database with the user-entered credentials. If the user is
authenticated (e.g., 804, option "Yes"), the gaming server may query,
e.g., 806, a game database for an app to provide for the user, based on
the details of the user's app request. The server may provide, e.g., 807,
the retrieved app for the user to the client device, using e.g., an IP
address for the client device included in the app request message
originally provided by the user. The client, upon obtaining the app may
execute, if required (e.g., 804, Option "Yes"), any installation
procedures, e.g., 812, required to install the app on the client device.
The client may then interpret an initial session state as provided by the
app, e.g., 813, (e.g., execute the instructions provided by the app), and
render a display for the user, e.g., 814, via a display device of the
user. For example, the client may obtain a Shockwave Flash (*.swf) object
from the server, and may invoke an Adobe® Flash web browser plug-in
to process and display the *.swf object for the user.

[0057] In some implementations, the client device and gaming server may
generate a session, e.g., 808, for the user/client to facilitate (secure)
communications between the client and the server. For example, an
Adobe® Flash object running within a browser environment on the
client may include ActionScript® 3.0 commands to create a Secure
Sockets Layer ("SSL") connection with a server, e.g., 809, and the server
may be implementing a PHP script implementing a SSL socket server which
listens to incoming communications on a server port to which the client
device sends data, as described previously. Upon generating the session
with the client, the gaming server may provide, e.g., 810, (e.g., using
PHP/SQL commands such as described in the example above) the details of
the session to a gaming environment database, including, but not limited
to: gaming server ID, user ID, user name, app name, app ID, socket ID,
socket expiry time, socket bandwidth, communication protocols, security
protocols, communication priority level, and/or the like. Upon receiving
the session details, the gaming environment database may store the
session details for later use.

[0058] FIGS. 9A-B are of data flow diagrams illustrating example aspects
of implementing user gaming interactions with the OBM within a user
gaming session in some embodiments of the OBM. In some implementations,
the app may include interactive features, and may allow the user to
provide user input/feedback, e.g. 921, via a variety of mechanisms (e.g.,
keyboard entry into a command-line interface, mouse input in a graphical
user interface, gestures on a touch-sensitive interface, voice commands,
etc.). In some implementations, the client device executing the app may
generate, maintain, update and/or store data pertaining to the user's
interaction with the app (e.g., an app state, an app data structure, a
block of memory with data variables, a Flash movie clip, etc.). For
example, the app may store a data structure encoded according to the
JavaScript Object Notation ("JSON") format. An exemplary JSON-encoded
data structure is provided below:

[0059] In some implementations, the gaming server may generate a secure
communications session with the client in order to facilitate
communication during the user gaming experience between the client and
gaming server. As an example, the app may provide data stored on the
client device for the gaming server as user game input, e.g., 922. For
example, an Adobe® Flash object running on the client may include
ActionScript® 3.0 commands to create a Secure Sockets Layer ("SSL")
connection with a server, generate a message including a JSON-encoded
data structure such as illustrated in the example above, and send the
message via the secure SSL connection to the server. Exemplary commands,
written substantially in the form of ActionScript® 3.0, to create a
secure SSL connection to a server, load data from a locally stored
JSON-encoded data file, and send a message including the JSON-encoded
data via the SSL connection to the server, are provided below:

[0060] In some implementations, the gaming server may be executing a PHP
script implementing a Secure Sockets Layer ("SSL") socket server which
listens to incoming communications on a server port to which the client
device may send data, e.g., data encoded according to the JavaScript
Object Notation ("JSON") format. Upon identifying an incoming
communication, the PHP script may read the incoming message from the
client device, parse the received JSON-encoded text data to extract
information from the JSON-encoded text data into PHP script variables,
and store the data (e.g., user gaming input, user session state 930)
and/or extracted information in a relational database accessible using
the Structured Query Language ("SQL"). An exemplary listing, written
substantially in the form of PHP/SQL commands, to accept JSON-encoded
game input data from a client device via a SSL connection, parse the data
to extract variables, and store the data to a database, is provided
below:

[0061] In some implementations, the gaming server may require clearance
from various OBM components prior to servicing the user's gaming input.
For example, a social gaming behavior evaluator component (e.g., 1200)
may be implementing a virtual security camera (e.g., 1500), customer
service request evaluator (e.g., 1700), live online game tester (e.g.,
1900, 2000), engagement-tracking game modifier (e.g., 2100, 2200) and/or
other processes that may provide or withhold clearance to the gaming
server to process the user's gaming input. In such implementations, the
gaming server may generate a clearance request, e.g., 923, and provide
the clearance request, e.g., 924, to the social gaming behavior evaluator
component. For example, the gaming server may provide a HTTP(S) POST
message including the clearance request, and data (e.g., user's gaming
input) that the social-gaming behavior component requires to process the
clearance request. An exemplary HTTP(S) POST clearance request message is
provided below:

[0062] In some implementations, the social-gaming behavior evaluator may
provide a clearance acknowledgment message, e.g., 925a, indicating that
the gaming server is cleared to process the user's gaming input provided
by the user as part of the user's interaction with the gaming app. For
example, the social-gaming behavior evaluator may provide a HTTP(S) POST
message similar to the example provided below:

[0063] In some implementations, the gaming server may require, to service
the user's requests while utilizing the app, game rules and/or require
environment data related to the user's current gaming environment (e.g.,
what are the cards being held by the other players in a game of poker?,
what are the actions of the members of the user's mafia?, etc.). The
gaming server may utilize the environment data, e.g., 928, as stored in
gaming realm database(s), and the user's gaming input to compute an
updated user session state for the client (e.g., representing change of
the state of the game, actions of the game player/co-player(s) within the
game, etc.). For example, a gaming realm database may store environment
data including, but not limited to, user session state(s), such as the
exemplary illustrative JSON-encoded user session state data structure
provided below:

[0064] In some implementations, the gaming server may utilize the a game
ID of the game in progress to query its gaming realm database to identify
the user IDs of the users involved in the game, and identify IP addresses
of the gaming realm database(s) storing the user session states of the
identified users. The gaming sever may utilize the above data to
generate, e.g., 926, environment queries for the user session states
required to process the user's gaming input. The gaming server may then
query, e.g., 927, the identified gaming realm database(s) for the user
sessions states of the users. For example, the gaming server may utilize
PHP/SQL commands similar to the exemplary illustrative commands provided
below:

[0065] Upon obtaining the user sessions states for the players in the
game, the gaming server may compute a new session state(s) for the
user(s), e.g., 929. The gaming server may save the new session state(s)
for the user(s) to the gaming realm database, e.g., 930. For example, the
gaming server may utilize PHP/SQL commands similar to those illustrated
in the example above with regard to storing gaming input data in the
gaming realm database. In some implementations, the gaming server may
provide results of the computation for the client. For example, the
gaming server may generate a data structure representative of a scalable
vector illustration, e.g., a Scalable Vector Graphics ("SVG") data file
such as render data, e.g., 931. The data structure may include, for
example, data representing a vector illustration. An exemplary vector
illustration data structure (an XML-encoded SVG data file, written
substantially according to the World-Wide Web Consortium's SVG standard),
and including data for an example vector illustration comprising a
circle, an open path, a closed polyline composed of a plurality of line
segments, and a polygon, is provided below:

[0066] The gaming server may provide the render data via one or more
HTTP(S) POST messages and/or using an SSL connection with the client,
e.g., as illustrated in examples provided above in this disclosure. Upon
obtaining the render data, the client may render, e.g., 932, the
visualization represented in the data structure for display to the user,
e.g., 933. For example, the client may be executing an Adobe® Flash
object within a browser environment including ActionScript® 3.0
commands to render the visualization represented in the data structure,
and display the rendered visualization for the user. Exemplary commands,
written substantially in a form adapted to ActionScript® 3.0, for
rendering a visualization of a scene within an Adobe® Flash object
with appropriate dimensions and specified image quality are provided
below:

[0067] In some implementations, the social-gaming behavior evaluator may
withhold clearance for processing the user's gaming input, and instead
provide a Constraint of Service ("CoS") order, e.g., 925b, indicating
that the gaming server is not cleared to process the user's gaming input
provided by the user as part of the user's interaction with the gaming
app. For example, the social-gaming behavior evaluator may provide a
HTTP(S) POST CoS message similar to the example provided below:

[0068] In such implementations, the gaming server may obtain the CoS
order, parse the CoS order, e.g., 934, to determine further action. In
some implementations, the CoS order may specify user(s) that need to be
locked out of the OBM. The gaming server may, in response, delete, e.g.,
936, the user sessions/states of the locked out users, e.g., by issuing
PHP/SQL commands to the gaming environment database. The gaming server
may also, based on parsing the order, generate warnings, notices,
complaints, reports, and/or the like, and provide, e.g., 935, the
generated outputs to the user/client, law enforcement, supervisors of the
OBM, etc. For example, the gaming server may utilize PHP commands similar
those presented below:

[0069] The client may obtain warnings, complaints, reports, notices, etc.
sent by the gaming server. The client may interpret the received
messages, e.g., 937, and display, e.g., 938, them for the user, e.g., via
an Adobe® Flash object issuing ActionScript® 3.0 commands as
illustrates in examples above.

[0070] FIGS. 10A-C are of logic flow diagrams illustrating example aspects
of implementing user gaming interactions with the OBM within a user
gaming session in some embodiments of the OBM, e.g., a user gaming
interaction ("UGI") component 1000. In some implementations, the app
executing on the client may include interactive features for the user.
For example, the app may be configured to accept user input/feedback via
a variety of mechanisms including, but not limited to, keyboard entry,
mouse input, touch input, touch gestures, voice commands, auto-form
filling, and/or the like. The app may provide a variety of user
interfaces configured to accept such input from the user including, but
not limited to, command line keyboard entry interfaces, graphical user
interfaces, touch-sensitive interfaces, and/or the like. In some
implementations, the user may interact, e.g., 1001, with the app and
provide input into the app. For example, the user may provide input as
part of a gaming application, a social application (e.g., chat room,
instant messaging, etc.), information resource selection, and/or the
like. The client device may detect input from the user. For example, the
client may include hardware resources (e.g., keyboard, mouse, etc.) that
provide triggers when a user manipulates the input hardware resources.
Upon detecting user input, the client may obtain such user input, and
determine whether the provided input is sufficient for the action and/or
circumstances within the app at the time of user input. For example, the
app may be configured to only accept user credentials input if the user
credential input is longer than a predetermined number of characters. If
the input is determined to be insufficient, the client may indicate to
the user to provide further input, and may wait for the requested user
input to be provided. If the input is determined to be sufficient for the
app to complete the action for which it requested/is provided the input,
the app may incorporate the input into the interactive user experience,
and proceed with instructions execution according to the satisfactory
user input. In some implementations, the client executing the app may
generate, maintain, update and/or store, e.g., 1002, data pertaining to
the user's interaction with the app (e.g., an app state, an app data
structure, a block of memory with data variables, a Flash movie clip,
etc.). In some implementations, the client may determine whether to
provide data stored on the client for a server, e.g., 1003. If the client
determines that data should be provided for the server (e.g., 1004,
option "Yes"), the client may prepare the data for transmission and
provide the data, e.g., 1005, for the server, for example, via a HTTP(S)
POST messages and/or secure SSL connection with the server as discussed
previously.

[0071] In some implementations, the gaming server may, upon obtaining the
user/client data/state, generate a clearance request, e.g., 1006, using
the obtained user/client data/state. For example, the gaming server may
provide a clearance request to obtain clearance to process the user's
gaming input pertaining to the user and the co-users who are included in
the game/realm in which the user is playing. The gaming server may
provide the clearance request, e.g., 1007 (for example, via one or more
HTTP(S) POST messages) to a social-gaming behavior evaluator (e.g., the
example social-gaming behavior evaluation component 1200 discussed below
with reference to FIG. 12). The social-gaming behavior evaluator may,
e.g., 10008-1010, determine whether to provide a clearance acknowledgment
message (e.g., 1009, option "Yes") or a Constraint of Service ("CoS")
order (e.g., 1009, option "No"). If the social-gaming behavior evaluator
provides a CoS order, e.g., 1010a, the gaming server may obtain the CoS
order, and parse the CoS order to determine its further procedures. For
example the gaming server may parse a CoS order formatted according to
the JSON-encoding standard using PHP commands as described in examples
above with reference to FIGS. 9A-B.

[0072] In some implementations, if the CoS order requires generating user
warnings for one or more users (e.g., 1012, option "Yes"), the gaming
server may parse the CoS order to determine the user ID(s) to which the
warnings need to be directed, and the content of the warning message(s),
e.g., 1013. The gaming server may generate the required warnings using
the parsed user ID(s) and warning message(s) content, e.g., 1014, and
provide, e.g., 1015 the user warning message(s), e.g., using the mail( )
PHP command as illustrated previously. In some implementations, if the
CoS order requires generating reports, complaints and/or legal notices
for one or more users and/or other OBM-affiliated entities (e.g., 1016,
option "Yes"), the gaming server may parse, e.g., 1017 the CoS order to
determine the user ID(s) of the user to whom the reports, complaints,
legal notices, etc. are related. The gaming server may also determine,
based on the parsing, the content of the reports, complaints, legal
notices, etc. The gaming server may query, e.g., 1018, the gaming
environment database for the user profiles, game status, and/or other
gaming environment data related to the user ID(s). The gaming server may
provide, e.g., 1019, these user profiles for, e.g., law enforcement,
security personnel, supervisory personnel etc. The gaming server may also
generate the required warnings using the content obtained from parsing
the CoS order, e.g., 1020. The gaming server may then provide, e.g.,
1021, the generated reports, complaints, legal notices, etc., using, for
example, the mail( ) PHP command as illustrated previously. In some
implementations, if the CoS order requires that one or more users be
locked out of the OBM (e.g., 1022, option "Yes"), the gaming server may
parse the CoS order to determine the user ID(s) of the user to be locked
out, e.g., 1023. The gaming server may then terminate, e.g., 1024, the
user sessions corresponding to the user ID(s) (e.g., using the example
gaming session termination component 1300 described with reference to
FIG. 13). In some implementations, the gaming server may further
modify/update, e.g., 1025, the user profile(s) of the user(s) so that the
user(s) cannot login again (e.g., permanent lock-out, temporary lock-out,
lock-out until user performs a remedial action such as paying a fine,
signing an agreement, agreeing to gaming restrictions, etc.). The gaming
server may provide, e.g., 1026, the updated user profile(s) for storing
in the gaming environment database, e.g., 1027.

[0073] In some implementations, if the social-gaming behavior evaluator
provides a clearance acknowledgment (e.g., 1010b), the gaming server may
generate queries for environment data, e.g., 1028, stored in gaming realm
database(s), pertaining to the user and the co-users who are included in
the game/realm in which the user is playing. The gaming realm database
may provide, e.g., 1029, the requested gaming environment data. For
example, the gaming realm database may provide environment data
including, but not limited to, user session state(s), such as the
exemplary illustrative JSON-encoded user session state data structures
provided in the examples above. The server may utilize the environment
data for the user(s) provided by the gaming realm database, as well as
the user's gaming input, to compute, e.g., 1030, an updated user session
state for the client (e.g., representing change of the state of the game,
actions of the game player/co-player(s) within the game, etc.). The
gaming server may provide the updated user session state, e.g., 1031, for
the gaming environment database, and may also provide the computed
updated user session state for the client, e.g., 1032. In some
implementations, the server may provide render data (e.g., an XML-encoded
SVG data file) via one or more HTTP(S) POST messages and/or using an SSL
connection with the client, e.g., as illustrated in examples provided
above in this disclosure. Upon obtaining the render data, the client may
render, e.g., 1033, the visualization represented in the data structure
for display to the user, e.g., 1034 (for example, using ActionScript®
commands within an Adobe® Flash object).

[0074] FIGS. 11A-B are of data flow diagrams illustrating example aspects
of evaluating a user's online social and/or gaming behavior in some
embodiments of the OBM. In some implementations, a gaming server, e.g.,
1103a, may provide a clearance request, e.g., 1121, for an evaluation
server, e.g., 1103b, to obtain clearance to process a user's gaming
input. For example, the gaming server may provide a HTTP(S) POST message
including the request for clearance and JSON-encoded user session state
data, as shown in examples above with reference to FIGS. 9A-B. In various
other implementations, other OBM components and/or other affiliated
entities (e.g., user, client, evaluation server, law enforcement agency,
security personnel, etc.) may provide clearance request(s) related to one
or more users. The evaluation server may parse the received clearance
request (e.g., using PHP commands to implement a JSON parser, as shown in
an example above with reference to FIGS. 9A-B), and obtain a game ID of
the game being played by the user, e.g., 1122. The evaluation server may
a generate a request for evaluation rules using the game ID as a search
parameter, and provide the evaluation rule request, e.g., 1123, for an
evaluation rules database, e.g., 1104c. For example, the evaluation
server may issue PHP/SQL commands (similar to the examples described
previously) to query the evaluation rules database for rule pertaining to
the game, identified by the game ID, being played by the user. In
response, the evaluation rules database may provide a set of evaluation
rules, e.g., 1124. For example, the evaluation rules database may provide
an XML-encoded data file including the evaluation rules that pertain to
the identified game. An exemplary listing of an XML-encoded evaluation
rule is provided below:

[0075] In some implementations, the evaluation server may parse, e.g.,
1125, the received evaluation rules, and determine the social-gaming data
required to process the evaluation rules for the user, e.g., 1125. For
illustration, the evaluation server may parse the example XML-encoded
rule illustrated above and determine that it requires social-gaming
threads for the user and the co-users of the game in order to process the
evaluation rule, based on parsing the <inputs> tag of the
evaluation rule. The evaluation server may generate requests for data as
specified by the evaluation rule. In some implementations, the evaluation
rule may require the evaluation server to obtain the rules of the game
identified by the game ID. The evaluation server may generate and issue a
game rules request (e.g., via PHP/SQL commands) to a game database, e.g.,
1104a, for the rules governing the game play within the game identified
by the game ID. In response, the game database may provide, e.g., 1127,
the request game rules, e.g., as XML-encoded data similar to the example
XML encoded evaluation rules provided above. In some implementations, the
evaluation rule may require that the evaluation server identify the
co-users of the game identified by the game ID of the user (e.g., the
example evaluation rule provided above requires the evaluation server to
determine the social-gaming thread for the co-users of the game, thus
requiring the evaluation server to identify the co-users of the game). In
such implementations, the evaluation server may issue a query (e.g., via
PHP/SQL commands to a relational database) for the gaming environment of
the game identified by the game ID. For example, the evaluation server
may issue a game environment request, e.g., 1128, to the gaming
environment database, e.g., 1104b, for the game environment data for all
co-users who are participating in the game identified by the game ID. For
example, the gaming server may utilize PHP/SQL commands similar to the
exemplary illustrative commands provided below:

[0076] As another example, the gaming environment database may have stored
a table including a list of game IDs, and lists of co-user IDs associated
with each of the game IDs in the table, and the evaluation server may
query the gaming environment database for the list of users corresponding
to the identified game ID. In response to the evaluation server's
queries, the gaming environment database may provide the requested
environment data, e.g., 1129, for the evaluation server. The evaluation
server may parse, if needed, the environment data to extract the user
ID(s) of the user(s) playing the game, e.g., 1130. In some
implementations, the evaluation rule may require the evaluation server to
obtain the gaming patterns of the users of the game, e.g., for a
predetermined period of time. The evaluation server may, in response,
issue a gaming patterns request, e.g., 1131, to a gaming behavior
database, e.g., 1104d. For the example, the evaluation server may issue
PHP/SQML commands to query the gaming behavior database for the gaming
patterns data. In some implementations, the evaluation server may provide
the gaming environment data obtained from the gaming realm database,
and/or gaming patterns data updated using the gaming environment data,
for the gaming behavior database in order to update the gaming patterns
data stored in the gaming behavior database. In response to the gaming
patterns request, the gaming behavior database may provide the requested
gaming patterns data (e.g., as database records) for the identified user
IDs associated with the game ID of the game, e.g., 1132. In some
implementations, the evaluation rule may require the evaluation server to
obtain social activity data, e.g., activity of the user and/or co-users
of the game on a social networking service (e.g., Facebook®,
Twitter', etc.). In such implementations, the evaluation server may issue
(e.g., via PHP/SQML commands) a social patterns request, e.g., 1133, to a
social behavior database, e.g., 1104e. In response, the social behavior
database may provide the requested social patterns data, e.g., 1134, for
the evaluation server (e.g., as records from the database). For example,
the records may include fields such as, but not limited to: user ID,
friend ID(s), friend relationship strength(s), social activity
timestamp(s), message ID(s), message(s), and/or the like, and/or the
like. In some implementations, the evaluation server may determine that
the social patterns data from the social behavior database if not
sufficient (e.g., using social activity timestamps to determine that the
data available does not cover the entire time period required by the
evaluation rule, data is outdated, data is incomplete, etc.). In such
implementations, the evaluation server may query a social networking
server (e.g., a Facebook® server) providing a service utilized by the
user and his/her friends for social data (e.g., new social activity
request 1136). For example, the evaluation server may invoke an
application programming interface ("API") call to the social networking
server. The evaluation server may request that the user log in to the
social networking service to provide the evaluation server access to the
user's social data. For example, the evaluation server may provide an
HTML page to the client including authentication commands similar to the
exemplary illustrative listing provided below:

[0077] The evaluation server may then generate and provide a request for
social data including, but not limited to: user ID, friend ID(s), friend
relationship strength(s), social activity timestamp(s), message ID(s),
message(s), and/or the like. For example, the evaluation server may
execute PHP commands similar to those in the exemplary illustrative
listing provided below:

[0078] In response, the social networking server may query (e.g., social
data request 1137) its own database (e.g., social activity database
1104f), and obtained the requested data from its database (e.g., social
data 1138). The social networking server may provide the retrieved
information for the evaluation server, e.g., new social activity 1139.
For example, the social networking server may provide a JavaScript Object
Notation format ("JSON")-encoded data structure embodying the requested
information. An exemplary JSON-encoded data structure embodying social
data (e.g., user ID(s) of friends of the logged-in user) is provided
below:

[0079] In some implementations, the evaluation server may utilize the
social patterns data from the social behavior database and the new social
activity data from the social networking server to generate updated
social patterns data records for the social behavior database. The
evaluation server may, (e.g., via PHO/SQL commands) issue orders to
update the social behavior database using the updated social activity
patterns data records. In some implementations, the evaluation server may
parse the data for the social and gaming activities of a user, and
identify activity timestamps associated with each of the social and/or
gaming actions of the user. The evaluation server may utilize the
activity timestamps to generate a social-gaming activity timeline for the
user, to process the evaluation rule. The evaluation server may generate
a timeline for each user that whose actions are required to be analyzed
to process the evaluation rule. The evaluation server may, in some
implementations, also parse each of the activities of a user to determine
the co-user at whom the activity was directed (e.g., to whom did the user
send the message?; to whom did the user provide a gift?). The evaluation
server may then generate social-gaming threads, e.g., 1140, for each user
that include data on the user's activities and their associated activity
timestamps, as well as activities of co-users at whom the user's actions
were directed, and their associated timestamps (e.g., wherein the
activities of the user and co-users are combined and arranged in reverse
chronological order).

[0080] In some implementations, upon generation of the social-gaming
activity timeline and/or social-gaming thread for the user, the
evaluation server may apply the processing procedures prescribed in the
evaluation rule to the social-gaming activity timeline(s) and/or
social-gaming thread(s). For example, in the exemplary evaluation rule
provided in the example above, the social gaming server may search the
user's social-gaming thread for social loops (e.g., favor/gift/(virtual)
currency transaction, etc. from the user to a co-user, and a return
favor/gift/(virtual) currency transaction, etc. from the co-user to the
user), and determine a percentage of co-users with whom the user creates
completed social loops. In some implementations, the evaluation server
may generate a score for an evaluation rule, and compare the score
against threshold value(s). For example, the exemplary evaluation rule
presented above prescribes a 25% minimum threshold for the percentage of
co-users with whom the user has completed social loops, below which the
evaluation rule will require generation of a rule violation flag by the
evaluation server. The evaluation server may implement such a procedure
to process each evaluation rule assigned to the game being played by the
user, and generate evaluation rule scores and/or flags as dictated by the
evaluation rules. If a flag is generated, and/or if an evaluation scores
does not adhere to a prescribed threshold, the evaluation server may
generate warnings, complaints, reports, legal notices, etc., for
providing the user, co-user(s), supervisory personnel, security
personnel, law enforcement agencies, and/or the like. The evaluation
server may generate a clearance acknowledgment message (e.g., a HTTP(S)
POST message including JSON-encoded data) if all evaluation rules are
satisfied, or may generate a Constraint of Service (CoS) order (e.g., a
HTTP(S) POST message including JSON-encoded data) if any of the
evaluation rules are violated and/or flags are generated based on
processing of the evaluation rules. The evaluation server may provide the
clearance acknowledgment and/or CoS order to the gaming server, e.g.,
1142.

[0081] FIGS. 12A-E are of logic flow diagrams illustrating example aspects
of evaluating a user's online social and/or gaming behavior in some
embodiments of the OBM, e.g., a social gaming behavior evaluation
("SGBE") component 1200. In some implementations, a gaming server, e.g.,
1103a, may provide a clearance request, e.g., 1201, and/or the user's
gaming data/session state for an evaluation server to obtain clearance to
process a user's gaming input (e.g., via an SSL connection with the
evaluation server). In other implementations, any OBM components and/or
other affiliated entities (e.g., user, client, evaluation server, law
enforcement agency, security personnel, etc.) may provide clearance
request(s) related to one or more users. The evaluation server may parse,
e.g. 1202 the received clearance request and/or the user's gaming
data/session state, e.g., using PHP commands to implement a JSON parser,
as shown in the example listing below:

[0082] The evaluation server may obtain, based on parsing the clearance
request and/or provided user gaming data/session state, a game ID of the
game being played by the user, e.g., 1202. The evaluation server may a
generate a request for evaluation rules using the game ID as a search
parameter, e.g., 1203, and provide the evaluation rule request, e.g.,
1204, for an evaluation rules database. In response, the evaluation rules
database may provide the requested evaluation rules, e.g., 1205. In some
implementations, the evaluation server may parse, e.g., 1206, the
received evaluation rules (e.g., using PHP commands similar to the
example above). The evaluation server may determine the social-gaming
data required to continue processing the evaluation rules for the user,
e.g., 1206. The evaluation server may generate requests for data as
specified by the evaluation rule. In some implementations, the evaluation
rule may require the evaluation server to obtain the game rules of the
game identified by the game ID (e.g., 2107, option "Yes"). If so, the
evaluation server may generate, e.g., 1208, and issue a game rules
request (e.g., 1209) to a game database. In response, the game database
may provide, e.g., 1210, the request game rules, e.g., as XML-encoded
data similar to the example XML encoded evaluation rules provided above.
In some implementations, the evaluation server may require the gaming
environment of the game being played by the user (e.g., 1211, option
"Yes"). The evaluation server may issue a game environment request, e.g.,
1212-1213, to the gaming environment database using the game ID and/or
user ID as search terms in, e.g., a PHP/SQL command. In response, the
gaming environment database may provide the requested game environment
data, e.g., 1214, for the evaluation server. The evaluation server may
parse, if needed, the environment data to extract the user ID(s) of the
user(s) playing the game, e.g., 1215. In some implementations, the
evaluation server may determine that the rule requires the evaluation
server to obtain the gaming patterns of the users of the game (e.g.,
1216, option "Yes"). The evaluation server may generate and issue a
gaming patterns request, e.g., 1217-1218, to a gaming behavior database.
In response to the gaming patterns request, the gaming behavior database
may provide the requested gaming patterns data (e.g., 1219) for the
identified user IDs associated with the game ID of the game. In some
implementations, the evaluation rule may require the evaluation server to
obtain social activity data (e.g., 1220, option "Yes") for a user. In
such implementations, the evaluation server may generate and issue, e.g.,
1221-1222, a social patterns request (e.g., PHP/SQML commands) to a
social behavior database for the user's social activity data. In
response, the social behavior database may provide the requested social
patterns data, e.g., 1223, for the evaluation server. In some
implementations, the evaluation server may parse the social activity data
and extract the timestamps from the social activity data obtained from
the social behavior database. The evaluation server may compare the range
of activity timestamps against the requirements of the evaluation rule
(which the evaluation server may obtain, e.g., by parsing the evaluation
rule). Based on the comparison, the evaluation server may determine
whether any additional (e.g., new) social data is needed (e.g., social
graph, activity data, etc.). If the evaluation server determines that
additional social data is needed (e.g., 1225, option "Yes`), the
evaluation server may query a social networking service utilized by the
user and his/her friends for social data (e.g., 1226-1227). In response
the social networking service may provide the requested social data for
the evaluation server, e.g., 1228. The evaluation server may aggregate,
e.g., 1229, the social patterns data from the social behavior database
and the social networking server to generate updated social patterns data
records (which the evaluation may provide for updating the social
behavior database). The evaluation server may parse the data for the
social and gaming activities of a user, and identify activity timestamps
associated with each of the social and/or gaming actions of the user. The
evaluation server may arrange the timestamps in, e.g., reverse
chronological order, in a data structure (e.g., SQL table with one column
dedicated to activity timestamps). The evaluation may then include the
social and/or gaming data (e.g., messages, gaming actions, currency
transactions, etc.) as additional columns within the table, associated
with the activity timestamps column. Accordingly, the evaluation server
may generate a data structure (e.g., SQL table) representing a
social-gaming activity timeline for the user. The evaluation server may
generate such a timeline for each user that whose actions are required to
be analyzed to process the evaluation rule, e.g., 1230. The evaluation
server may also generate a column in the data structure representing a
co-user at whom each activity in the user's social-gaming activity
timeline was directed at. Using the data, e.g., in this column, the
evaluation server may generate a social-gaming thread, e.g., 1231, for
each user for whom the evaluation server determines a social-gaming
thread is required for processing the evaluation rule. For example, while
generating the social-gaming thread for a user, the evaluation server may
search through the social-gaming activity timelines of each of the
co-users at whom the user has directed one or more actions in the user's
social-gaming activity timeline. The evaluation server may identify
actions in the social-gaming activity timelines of the co-users that were
directed back at the user, and may parse these records in the co-user
social-gaming activity timelines to determine whether their activities
were made in response to, or drew a response by way of, the user actions
in the user's social-gaming activity timeline. The evaluation server may
copy such identified records from the co-user social-gaming activity
timelines, and add them in to the social-gaming thread of the user,
(re)arranging all the records in the user's social-gaming thread in,
e.g., reverse chronological order.

[0083] In some implementations, upon generation of the social-gaming
activity timeline and/or social-gaming thread for a user, the evaluation
server may apply the evaluation rules for the identified game ID to the
social-gaming activity timeline(s) and/or social-gaming thread(s) of the
user. For example, the evaluation server may obtain an evaluation rule,
e.g., 1232. The server may parse the evaluation rule, and determine the
user ID of users whose activities are to be examined, based on the
evaluation rule, e.g., 1233. The server may utilize the user ID(s) to
select and obtain the social-gaming activity timelines and/or
social-gaming threads for the identified user(s), e.g., 1234. The
evaluation server may apply the processing procedures described in the
evaluation rule to the social-gaming activity timelines and/or
social-gaming threads of the user(s), e.g., 1235. Based on the
application of the evaluation procedures described in the evaluation
rule, the evaluation server may generate a score, e.g., 1236, for each
user, for each evaluation rule. The evaluation server may also parse the
evaluation rule, and obtain threshold value(s) against which to compare
the evaluation score(s), to determine whether to generate (general) rule
violation/Constraint of Service ("CoS") flags, e.g., 1239. If the
evaluation server generates any flags (e.g., 1240, option "Yes"), then
the evaluation server may parse the evaluation rule to determine the
outputs (e.g., warnings, notices, complaints, lock-out orders, etc.) that
the evaluation server needs to produce. The evaluation server may
generate, e.g., 1242, the required outputs based on the parsing of the
evaluation rule (e.g., in the example rule presented earlier, for the
instructions under the <output> tag). The evaluation server may
append the generated outputs to a CoS order, e.g., 1243, and/or provide
the generated output(s) to the respective parties as specified in the
evaluation rule. The evaluation server continues such a procedure until
all the evaluation rules pertaining to the game and/or user(s) have been
applied (e.g., 1244, option "Yes"). The evaluation server may determine
whether any of the flags generated during the evaluation procedure were
CoS flags (e.g., flags for which CoS orders need to be sent, and not
clearance acknowledgments). If no CoS flags were generated (e.g., 1245,
option "Yes"), the evaluation server may generate a clearance
acknowledgment, e.g., 1246, and provide the clearance acknowledgment,
e.g., 1247-1248, for the gaming server. If CoS flags were generated
(e.g., 1245, option "No"), then the evaluation server may provide, e.g.,
1249, the generated CoS order for the gaming server and/or other
component or affiliated entity that provided the clearance request.

[0084] FIG. 13 is of a logic flow diagram illustrating example aspects of
terminating a user gaming session with the OBM in some embodiments of the
OBM, e.g., a gaming session termination ("GST") component 1300. In some
implementations, the user may wish to terminate the session with the
server. For example, the user may close the application, log off from the
connection, stay dormant for a period of time, etc. The client may, in
such situations, generate a notification to leave the multi-user network
application, and provide the notification to the server. In other
implementations, the social-gaming behavior evaluator may issue a CoS
order to the gaming server, ordering the gaming server to lock the user
out. In other implementations, the gaming server may receive lock-out
orders from a supervisor, law enforcement agency, security personnel,
etc. Thus, a gaming session termination trigger may be obtained by the
gaming server from various OBM components and/or affiliated entities in
various implementations. Upon obtaining the gaming session termination
trigger, e.g., 1301, the server may terminate the session by ending
listening to the port to which the client was instructed to send user
requests, e.g., by deleting the user socket session 1302. The server may
also identify a session associated with the user ID of the user, and
generate 1303, e.g., PHP/SQL commands to the gaming environment database,
to delete the session of the user using the user ID. The server may
provide the commands to the gaming environment database, e.g. 1304, to
delete the record of the session from the database, upon which the gaming
environment database may update, e.g., 1305, its records by deleting the
record of the session for the user. The server may generate, in some
implementations, a notice (e.g., "You have been logged out . . . ", etc.)
and/or uninstall order for the client, and may provide the notice and/or
order, e.g., via a HTTP(S) POST message to the client. Upon receiving the
notice and/or order, the client may determine whether an uninstall order
was received. If the client determines that an uninstall order was
received (e.g., 1308, option "Yes"), the client may perform any
uninstallation procedures necessary to uninstall the client
application(s). The client may, upon uninstallation, generate an
uninstallation notice (e.g., 1310), and provide the notice to the server,
e.g., 1311.

[0085] FIG. 14 is of a table illustrating example evaluation rules for
implementing a virtual security camera using the OBM in some embodiments
of the OBM. In some implementations, a social-gaming behavior evaluation
component (e.g., the example SGBE 1200 component described with reference
to FIG. 12) may be utilized to deploy a virtual security camera
implementing features similar to those discussed with reference to FIG.
1. For example, the social-gaming behavior evaluation component may be
provided with virtual security camera evaluation rules that allow the
social-gaming behavior evaluation component to detect user attempts to
perform game actions that circumvent game rules, game conditions, user
collusion, misappropriation of another user's position in the game, etc.
For example, a virtual security camera evaluation rule 1401, an input
boundary circumvention rule, may prevent a user from providing an input
into a game that exceeds the limits set in the game rules for such input
(e.g., taking more cards in a poker game than allowed). An evaluation
server processing an input boundary circumvention may, e.g., need to
operate on gaming actions from a single user, and may require only the
game rules in order to perform its processing. Further, if the rule
processing generates a flag, the user may be provided with a notice
advising that the input provided exceeds the bounds set by the game
rules. As another example, a game conditions circumvention virtual
security camera rule, e.g., 1402, may apply to a single or multiple
users, and may require that the evaluation server processing the rule
obtain the game rules, and gaming environment data from the single or
multiple users (e.g., depending on the state of game play), and may
produce warnings and/or notices if any flags are raised by the processing
of the evaluation rule. As another example, an illegal user collusion
virtual security camera rule may require the evaluation server to obtain
data pertaining to a plurality of users. The evaluation server may obtain
the game rule, current gaming environment data, the prior gaming patterns
data for the users, prior social activity data for the users (e.g., to
generate social-gaming activity timelines and/or social-gaming threads),
and may generate complaints for security personnel, system supervisors,
law enforcement, etc. if any flags are generated by processing the
evaluation rule. The evaluation server may also instruct the gaming
server(s) providing gaming services for the user to lock the users out.
As another example, a user ID misappropriation virtual security camera
rule may not require the evaluation server to consider the game rules
and/or current gaming environment data, but rather obtain prior gaming
patterns data and/or social activity data to generate a social-gaming
activity timeline. For example, such a rule may be able to determine if
there was an abrupt change in the geo-location (e.g., based on IP
address) and/or game play times of the user that was not expected, e.g.,
based on the social activity messages provided by the user). It is to be
understood that any tables, evaluation matrices, rule sets and/or logic
may commute, cumulate, or otherwise operate in conjunction, in a
mathematical progression, or according to the specific scenario within
the game. For example, if several evaluation rules generate flags, then
the output actions of the evaluation server may be more severe than if
each evaluation rule raised flags separately. As another example, if
evaluation rule processing generated flags in the prior history of the
user(s), then a new flag raised by processing an evaluation rule may
generate more severe output actions than if there were no prior history
of flags for the user(s) involved. The amount of time lapsed since a
prior evaluation rule flag was generated for a user may also affect the
output action that the evaluation server orders for that user. Various
such permutations of inputs used, processing undertaken, and outputs
generated by the evaluation server may be built into the formulation of
the evaluation rules.

[0086] FIG. 15 is of a logic flow diagram illustrating example aspects of
implementing a virtual security camera for gaming within the OBM in some
embodiments of the OBM, e.g., a virtual security camera ("VSC") component
1500. In some implementations, a user may join 1501a gaming environment,
e.g., by using a gaming session initiation such as the example GSI 800
component discussed above with reference to FIGS. 8A-B. The user may
interact 1502 with the gaming environment and with co-users, e.g., via a
user gaming interaction component such as the example UGI 1000 component
discussed above with reference to FIGS. 10A-C. In some implementations,
the user may provide an input into the system, e.g., via the user gaming
interaction component. If the user input is determined by the OBM to not
be a request to log-out (e.g., 1503, option "No"), the OBM may evaluate
the user input 1504, e.g., via a social-gaming behavior evaluation
component such as the example SGBE 1200 component discussed above with
reference to FIGS. 12A-E. In some implementations, the social-gaming
behavior evaluation component may provide a clearance acknowledgment upon
evaluating the user input (e.g., 1505, option "Yes"). In such
implementations, the OBM may continue processing the user input 1506,
e.g., via the user gaming interaction component such as used in 1502.
Accordingly, the OBM may, in some implementations, evaluate each user
action for validity (e.g., using the social-gaming behavior evaluation
component) and process only user actions that are deemed to meet the
security consideration embodied within the virtual security camera rules.

[0087] In some implementations, the social-gaming behavior evaluation
component may generate a CoS order in response to being provided a user
input (e.g., 1505, option "No"). In such implementations, the OBM (e.g.,
a gaming server operating within the user gaming interaction component)
may, e.g., 1507, parse the CoS order, generate any reports, notices,
warnings, complaints, etc. and provide them to the necessary authorities
based on the instructions encoded into the evaluation rules. In some
implementations, the CoS order may include orders to constraint service
provided to the user without locking the user(s) out from the OBM (e.g.,
1508, option "No"). In such implementation, the OBM may continue
processing 1506 the user inputs, but the gaming environment of the user
may be modified in accordance with the instructions 19 provided in the
CoS order. If the CoS order includes instructions to lock a user out
(e.g., 1508, option "Yes"), the OBM may log the user out 1509, e.g.,
using a gaming session termination component such as the GST 1300
component discussed above with reference to FIG. 13.

[0088] FIG. 16 is of a table illustrating example evaluation rules for
implementing a customer service request evaluator using the OBM in some
embodiments of the OBM. In some implementations, a social-gaming behavior
evaluation component (e.g., the example SGBE 1200 component described
with reference to FIG. 12) may be utilized to deploy a customer service
request evaluator implementing features similar to those discussed with
reference to FIG. 2. For example, the social-gaming behavior evaluation
component may be provided with customer service request evaluation rules
that allow the social-gaming behavior evaluation component to evaluate
the reputation of a customer, a detect fraudulent customer service
request, identify a high-priority and/or low-priority customer, detect an
automated (e.g., spam) request, identify a single customer making
multiple requests by posing each time as a different customer (e.g.,
Sybil attack), etc. For example, a customer service request evaluation
rule 1601, a VIP identification rule, may identify a customer of high
priority based on the frequency with which the customer utilizes the
gaming and/or other features of the OBM. For example, the VIP
identification rule may be utilized to evaluate one customer at a time,
and may utilize the gaming pattern data and/or social activity data of
the customer (e.g., to detect frequency of use of social and/or gaming
features of the OBM) to determine a priority to be accorded to a service
request made by the user. If the VIP identification rule generates flags,
the OBM may provide clearance and provide a complimentary notice to the
user ("Thank you for coming back to us! . . . ," etc.). The OBM may also
assign a priority weight to the service request made by the user before
placing the request in a queue of requests. Accordingly, the OBM may
process customer service requests based on the prioritization accorded to
users based on the VIP identification rule.

[0089] As another example, Sybil attack detection customer service request
evaluation rule 1602 may require an evaluation server to utilize data
pertaining to multiple users. The evaluation server may utilize the
social and gaming pattern data for the multiple users to determine
whether a single person is actually posing as the multiple users being
evaluated under the Sybil attack detection rule. The evaluation server
may process this evaluation rule by generation a social-gaming timeline
for each user, and e.g., monitoring the geo-location, frequency of
requests, length of history of requests, etc. of the multiple user to
make a determination as to whether a Sybil attack is being carried out
using the multiple user IDs. If the evaluation server generates flags
while processing this evaluation rule, the evaluation server may generate
a CoS order providing notifications, complaints, etc., and locking out
the multiple user IDs determined to form part of the Sybil attack.

[0090] As another example, the evaluation server may process the automated
request detection evaluation rule to determine whether customer service
requests from a single or multiple user IDs are being generated
automatically (e.g., by a spambot). In such an example, the evaluation
server may obtain the social activity data pertaining to the single or
multiple users, and may generate a timeline for the single or multiple
users' social activity. The evaluation server may, e.g., determine
whether there have been isolated spikes of activity, or continuous
service requests originating from the user ID(s) to determine whether the
user ID(s) are being used in automated service request generation. If the
evaluation server generates flags while processing this evaluation rule,
the evaluation server may, e.g., generate a CoS order instructing the
gaming server to provide notices to the user(s), security personnel,
etc., and lock the user ID(s) out from the OBM.

[0091] As another example, the evaluation server may process fraudulent
request detection evaluation rule to determine whether customer service
requests from a single user ID are fraudulently placed (e.g., customer
service request to replace million dollar worth of virtual poker chips
because of glitch in client application, etc.). In such an example, the
evaluation server may obtain the gaming pattern and social activity data
pertaining to the single user, and may generate a timeline for the users'
social-gaming activity. The evaluation server may, e.g., determine
whether there was an abrupt disruption of social and/or gaming activity
and/or whether the gaming environment data abruptly changed due to
factors other than user input (e.g., perhaps indicative of an actual
software glitch). If the evaluation server, e.g., generates CoS flags
while processing this evaluation rule, the evaluation server may, e.g.,
generate a CoS order instructing the gaming server to provide complaints
to security personnel, law enforcement, OBM supervisors, etc., and lock
the user ID(s) out from the OBM.

[0092] A another example, the evaluation server may process a user action,
including a customer service request, by determining how the user's
social community behaved with the user. For example, the OBM may
determine the user's reputation based on how the user's co-user (e.g.,
from the user's social graph data) interacted with the user (were there
broken social loops?; did many of the user's requests to friends go
unanswered?; did co-users flag the user as being fraudulent on a social
networking service?; etc.). In such an example, the evaluation server may
obtain the gaming pattern and social activity data pertaining to the
single user, and may generate a timeline for the users' social-gaming
activity, as well as a social-gaming thread for the user using the
social-gaming activity timelines of the co-users of the user (e.g.,
inferred from the user's social activities and/or from the user's social
graph). The evaluation server may also parse the social activity of the
co-users of the user to find any messages posted with regard to the user.
The evaluation server may. for example, run keyword searches through the
social activity messages of the co-user of the user to find any messages
pertaining to the user. If the evaluation server, e.g., generates CoS
flags while processing this evaluation rule, the evaluation server may,
e.g., generate a clearance acknowledgment attesting to the good
reputation of the user, and may prioritize accordingly, any requests made
by the user over other users, e.g., those with lower reputation scores as
calculated by the evaluation server.

[0093] FIG. 17 is of a logic flow diagram illustrating example aspects of
implementing a customer service request evaluator within the OBM in some
embodiments of the OBM, e.g., a customer service request evaluator
("CSRE") component 1700. In some implementations, a user may provide 1701
a customer service request to the OBM. For example, the user may call a
representative via a telephone, and provide a customer service request.
The representative may then generate a clearance request message on
behalf of the user, e.g., 1702. In other implementations, a user may
initiate a gaming session (e.g., using a gaming session initiation
component such as the example GSI 800 component described above with
reference to FIGS. A-B) and provide the customer service request via the
gaming session (e.g., via a HTML input form; via a user gaming
interaction component such as the example UGI 1000 component described
above with reference to FIGS. 10A-C, etc.). In such implementations, a
gaming server (e.g., one that is part of the user gaming component being
utilized by the user) may provide a clearance request. The OBM may
provide the clearance request message for a social-gaming behavior
evaluator component (e.g., the example SGBE 1200 component discussed
above with reference to FIGS. 12A-E). The social gaming behavior
evaluator component may evaluate, e.g., 1703, the customer service
request message, e.g., utilizing customer service request evaluation
rules such as, but not limited to, the customer service request
evaluation rules described with reference to FIG. 16. If the
social-gaming behavior evaluator generates a CoS order (e.g., 1704,
option "No"), the OBM may deny the customer service request, and may
provide generated notices, complaints, reports to the user(s) and/or OBM
supervisor, security personnel, law enforcement agencies, etc. If the
social-gaming behavior evaluator evaluates the customer service request
favorably based on the application of the customer service request
evaluation rules, the social-gaming behavior evaluator may provide a
clearance acknowledgment (e.g., 1704, option "Yes") along with any
reports and/or notices. The OBM (e.g., gaming server providing the
clearance request message to the social-gaming behavior evaluator) may
parse any reports provided by the social-gaming behavior evaluator,
identify rule scores and/or any flags generated. The OBM may calculate a
priority score for the customer service request based on the rule scores
and/or flags. The OBM may then add the customer service request to a
customer service request queue, along with the priority score associated
with the customer service request.

[0094] FIGS. 18A-B are of block diagrams illustrating example aspects of
customer service request management in some embodiments of the OBM. In
some implementations, the OBM may select the next customer service
request to be processed according to a priority queuing process. In some
implementations, the OBM may determine the next customer service request
to process based on the order (e.g., using a timestamp submitted with
each customer service request) in which the customer service requests
entered the customer service request queue and a priority value assigned
to each of the customer service requests (e.g., the priority score
calculated by the OBM during customer service request evaluation by a
social-gaming behavior evaluator and/or other component of the OBM). Each
customer service request in a queue may be assigned a queue number
indicative of the order in which the customer service requests entered
the queue and a priority value indicative of the importance attached to
processing the customer service request. In some implementations, the OBM
may determine the customer service request priority values based on a
number of factors including, but not limited to, customer service request
ID, originator ID, and/or the like. In some implementations, the
computing server may assign relative importance to the order in which
customer service requests entered the queue and the priority value
assigned to any particular customer service requests using position
weights and/or priority weights. For example, a net priority value of a
customer service request ("Net CSR Priority Value") in a queue may be
determined by the OBM as the weighted sum of the queue position and the
customer service request priority, wherein the weights are the position
weight and the priority weight, as illustrated in FIG. 18A:

[0095] In such implementations, the customer service request next selected
for processing by the OBM may be identified as the customer service
request having the highest net customer service request priority value.
In further implementations, the OBM may utilize multiple queues for
customer service requests, such as the non-limiting exemplary
illustration in FIG. 18B. In some implementations, each queue may be
assigned a queue priority weight relative to the other queues for
customer service requests. In such implementations, the net priority
value of a customer service request may be weighted by the weight
assigned to its customer service request queue:

[0096] In some such implementations, the next customer service request
selected by the OBM for processing among the customer service requests in
all the queues may be the customer service request having the highest net
customer service request priority value, including the weighting assigned
to each of the customer service request queues in the queue database.

[0097] FIGS. 19A-B are of logic flow diagrams illustrating example aspects
of implementing live testing of online games within the OBM in some
embodiments of the OBM, e.g., a live online game tester ("LOGT")
component 1900. In some implementations, the OBM may advantageously be
utilized to perform live field tests of game features employing users
interacting within social-gaming networks, similar to the discussion
above with reference to FIG. 3. For example, users may be introduced into
an A/B testing scheme when they request an app from the OBM. For example,
in some implementations, a may request 1901 a gaming app from the OBM
(e.g., via a gaming session initiation component such as the GSI 800
component described above with reference to FIGS. 8A-B). The OBM may
determine whether to include the user in a live test. The OBM may also
add the user to a live test group or a control group, if the OBM
determines that the user will be included in the live test. For example,
the OBM may determine 1902 whether to add a user to a live test and/or to
which group to add the user based on factors including, but not limited
to: the geo-location of the user, the IP address of the user, a user
profile of the user, a reputation systems analysis of the user, for
example, using the example SBGE 1200 component in a customer service
request evaluator mode, and/or the like. If the OBM determines that the
user will be added to the test group (e.g., 1903, option "Yes"), the OBM
may, e.g., redirect the user's gaming app request to a gaming server that
provides 1904 the user with a gaming app including a new game feature
(e.g., modified in-game (virtual) item pricing, modified game speed, new
user interface element/design, etc.). In such implementations, the user
may interact 1905 with the test gaming environment presented by the
gaming app including the new game feature, e.g., using a user gaming
interaction component such as the example UGI 1000 component described
above with reference to FIGS. 10A-C. The user may, e.g., comment on the
new game feature on a social networking service, with the user's game
co-users via an in-game network, etc. The OBM may perform an evaluation
1906 of (e.g., parse) the user's social-gaming activity to determine
whether the user liked the new game feature or not. The OBM may, for
example, determine whether the user spent more money within the app,
whether the user invited other users to try out the new game feature,
whether the user commented on a social networking service post about the
game feature, whether the user's social graph accepted the invitation to
try the new game feature based on the user's invitations and/or comments
on the social networking service, etc. The OBM may, e.g., utilize a
social-gaming behavior evaluator such as the SGBE 1200 component to
perform the evaluation of the user's and co-users' social-gaming
behavior, generate 1907 evaluation score for the evaluation rules, and
generate reports based on the scores and flags generated by the
evaluation. The OBM may append 1908 the generated report for the user to
an aggregated test group score record. If the OBM determines that more
test subjects are needed (e.g., 1909, option "Yes"), the OBM may choose
the test subjects from among the co-users that the user invited. In some
implementations, the OBM may choose from among the co-user who viewed the
user's comments on the social networking service. In other
implementations, the OBM may eliminate the co-users of the user who have
heard of, or have been invited to, or have tried, the new game feature as
being biased in view of their exposure to the user's experience. It is to
be understood that any combination of selection or elimination strategies
may be employed to determine more users to use a test subjects in the
live online game test.

[0098] In some implementations, the OBM may determine that a user
requesting a gaming app be added to the control group of the live online
game test (e.g., 1903, option "No"). In such implementations, the may
redirect the user's gaming app request to a gaming server that provides
1910 the user with a gaming app that does not include the new game
feature. In such implementations, the user may interact 1911 with the
control gaming environment presented by the gaming app that does not
include the new game feature, e.g., using a user gaming interaction
component such as the example UGI 1000 component described above with
reference to FIGS. 10A-C. The OBM may perform an evaluation 1912 of the
user's gaming and/or social activity (e.g., via a SGBE 1200 component) in
a manner similar to that performed by the SGBE 1200 component for the
test users of the gaming app including the new game feature. The OBM may,
e.g., utilize a social-gaming behavior evaluator such as the SGBE 1200
component to perform the evaluation of the user's and co-users'
social-gaming behavior, generate 1913 evaluation score for the evaluation
rules, and generate reports based on the scores and flags generated by
the evaluation. The OBM may append 1914 the generated report for the
control user to an aggregated control group score record. If the OBM
determines that more test subjects are needed (e.g., 1909, option
"Yes")), the OBM may choose more control users using a combination of
user selection or elimination strategies as described above.

[0099] Upon completion of the live online game test using a sufficient
number of test and/or control group users, the OBM (e.g., an
evaluation/gaming server) may compare the test group score record to the
control group score record, e.g., 1915. The OBM may generate a score
comparison report based on the comparison, e.g., 1916, and provide the
score comparison report, e.g., for a developer, user interface designer,
game designer, game producer, etc.

[0100] FIG. 20 is of a logic flow diagram illustrating example aspects of
implementing live testing of a set of online game features within the OBM
in some embodiments of the OBM, e.g., a game feature set tester ("GFST")
component 2000. In some implementations, the OBM may test a suite of new
game features in a live A/B test using test and control group users from
the field. For example, the OBM may add 2001 a new game feature from a
set of new game features to a game environment. The OBM may test 2002 the
new game feature in a live online game test utilizing users from the
field (e.g., using a live online game tester component such as the
example LOGT 1900 component described above with reference to FIG. 19).
The OBM may generate a score comparison report comparing the scores
generated by the test group and the control group. Based on the score
comparison report, the OBM may determine whether the feature was well
adopted or not. If the feature was not well adopted (e.g., 2003, option
"No"), the OBM may determine, based on the score comparison report,
whether to continue testing other game features in the set. For example,
if the new game feature tested was not adopted well and was a core
feature of the new game feature set, the OBM may determine that further
testing of other features in the new game feature set is not needed
(e.g., 2004, option "No"). If the OBM determines that other set features
may be tested (e.g., 2004, option "Yes"), the OBM may, in some
implementations, attempt to increase the size of the test and control
groups. For example, the OBM may obtain 2005 a list of the users in the
test group that tested the current new game feature, and may provide an
option for these users to invite more users to join the game feature set
test and/or control groups (e.g., "Invite your friends to try out this
cool game theme!," etc.). The OBM may obtain user invitation selections,
and may send out invitations on behalf of the test group users to other
invited users, requesting them to join the live online game feature set
test. In some implementations, some of the invited users may accept to
join the live online game feature test set. In response, the OBM may add
2006 the user ID(s) to a pool of potential test group users. If there are
more game features in the set to test (e.g., 2007, option "Yes"), the OBM
may repeat the procedure described above until there are no new game
features in the set to be tested. It is to be understood that the OBM may
test any combination of game features available in the new game feature
set. The OBM may test different combinations of game features with
different test group users, and/or may introduce the new game features to
different users within the test group in different orders. Accordingly,
the OBM may test all combinations of features, and roll-out strategies
for the game features, in a live online game feature set test utilizing
users from the field.

[0101] FIGS. 21A-B are of logic flow diagrams illustrating example aspects
of implementing strategic game modification based on tracking engagement
of a single user within the OBM in some embodiments of the OBM, e.g., a
user engagement-tracking game modification ("U-ETGM") component 2100. In
some implementations, the user may be struggling to overcome a hurdle
(e.g., defeating a dragon in a particular stage of a game), and the user
may be playing the game lesser because of the difficulty. The OBM may, as
discussed previously with reference to FIG. 4, identify such users with
waning engagement levels, and attempt to improve the user's engagement
level by utilizing the user's social network. In some implementations,
the OBM may obtain an indication that a user is suffering from low
engagement in a gaming app. For example, in some implementations, the
user playing the app may click on link (e.g., within the app and/or
browsing environment) provided to notify a gaming server that the user
needs help (e.g., a hyperlink stating: "Need help defeating this dragon?
Friends Unite!", etc.). In some implementations, the OBM may detect low
engagement level of a user by monitoring the user's social-gaming
behavior, e.g., using a SGBE 1200 component as discussed above with
reference to FIGS. 12A-E. For example, the SGBE 1200 component may
generate a historical graph of the user's activity level within the
gaming app, and/or within the gaming network (e.g., if the user has
switched from playing one gaming app to playing another gaming app).
Accordingly, the OBM may obtain a trigger for initiating user
engagement-tracking game modification from a variety of sources, or in a
diagnostic manner. The trigger for engagement-tracking game modification
may be, e.g., a clearance request provided to a SGBE 1200 component of
the OBM (e.g., by the user, a gaming server, an evaluation server, and/or
other OBM-affiliated entities). In some implementations, the OBM may
obtain 2101 a clearance request and/or user gaming data/session state.
The OBM may, e.g., using a social-gaming behavior evaluator component
such as the example SGBE 1200 component, identify the user's co-users,
generate a social-gaming activity thread for the user and/or co-users,
and utilize the social-gaming threads to determine a subset of co-users
who are most likely to help the user. For example, the social-gaming
behavior evaluator may determine which co-users the user exchanged gifts
with the most, with which co-users did the user have the most number of
completed social loops, which co-users spent the most amount of money,
which co-users conducted the greatest number of transactions, which
co-users messaged the user the most, and/or the like. For example, the
social-gaming behavior evaluator may generate flags and/or scores based
on factor including, but not limited to, factors such as those listed
above. The OBM may identify 2102 which co-users are most likely to help,
or be able to help, the user based on the scores generated by the
social-gaming behavior evaluator.

[0102] In some implementations, the OBM may identify 2103 a hurdle within
a game that is causing the user to experience low engagement levels. For
example, each object within the gaming app may be assigned an object ID.
The OBM may determine which object ID is associated with the game feature
that the user is experiencing difficulty with. For example, the OBM may
utilize a social-gaming behavior evaluator to generate a social-gaming
activity timeline of the user experiencing a low engagement level, and
identify a temporal (e.g., stage within a game) and/or spatial (e.g.,
pixel sub-area within an Adobe® Flash object) position within the
gaming app at which point the user tends to stop playing the game within
a user session. In some implementations, each object ID and/or stage
within a gaming app may have a difficulty weight associated with it. In
some of these implementations, the difficulty weight of the object ID
and/or stage may be modifiable during the user's gaming session. In some
implementations, the OBM may lower the difficulty weight associated with
object ID and/or stage identified as being the object ID and/or stage at
which the user tends to stop playing the game.

[0103] In some implementations, the OBM may identify incentives that the
OBM can provide for the user and/or co-users determined by the OBM to be
likely to help the user achieve higher engagement levels. The OBM may
provide incentives to encourage the user to re-establish higher
engagement levels within the game, or may encourage the co-users to
contribute to increasing the user's engagement level. For example, the
OBM may obtain and/or parse the user profiles and/or social activity
messages of the user and co-users to identify keywords that the OBM can
use in a search for (virtual) products to offer for sale to the user
and/or co-users. The OBM may utilize the keywords to query 2104 a
(virtual) product database for items that may be offered to the user
and/or co-user. In some implementations, the OBM may also utilize
keywords related to the object ID within the app and/or the stage of the
game to query for items that may be offered for sale. The (virtual)
product database may provide search results listing products for the OBM
to offer to the user and/or co-users. The OBM may provide the (virtual)
items 2105 in a flash sale for the user, and/or co-users with an
invitation 2106 to the co-users to help the user overcome the hurdle in
the user's game. For example, the OBM may provide a message for a co-user
(e.g., "Jane needs help defeating the dragon. Buy from the items below at
special discounted prices; join Jane's game and use them to help her
fight the dragon!") encouraging the co-user to purchase an offered item,
and/or join the user's gaming environment to help the user overcome the
hurdle in the game. In some implementations, the OBM may reduce the
difficulty weight of the object ID and/or game stage upon co-users of the
user accepting the invitation to join the user's game to help overcome
the hurdle presented by the object ID and/or game stage within the game.
In some implementations, the OBM may provide, to co-users that help the
user, rewards and/or incentives within their own gaming apps and/or
offering further flash sales of items, e.g., at discounted prices because
the co-users helped the user overcome the hurdle in the user's game. For
example, the OBM may reduce the difficulty weight for objects and/or game
stages within the co-users' gaming apps so as to improve their engagement
levels within their own gaming apps. For example, the OBM may calculate
new difficulty weights 2107 for objects and/or game stages in the gaming
apps of the user and/or the co-users based on factors including, but not
limited to: number of items sold in the flash sale connected to the
invitation to help the user, number of co-users accepting the invitations
to help the user, amount of flash sales connected to the invitation to
help the user, and/or the like. In some implementations, upon the
co-users accepting the invitations, the OBM may process the co-users' and
user's sale item purchases (e.g., using an online shopping system such as
the OpenCart open-source online shopping solution). The OBM may also
inject the co-users into the gaming environment of the user (e.g., using
a gaming session initialization such as the example GSI 800 component).

[0104] In some implementations, the OBM may, e.g., 2109, utilize a
social-gaming behavior evaluator (e.g., SGBE 1200 component) to generate
a social-gaming activity timeline of the user, and determine whether the
user has progressed over the hurdle identified by the app object ID
and/or game stage. In some implementations, the OBM may also determine
whether the user requires any more help with the identified hurdle, or
any other hurdle the user may be experiencing within the game, e.g.,
2110. If the OBM determines that the user needs more help (e.g., 2111,
option "Yes"), the OBM may repeat a procedure similar to that discussed
above for the user until the OBM determines that the user's engagement
levels are comparable to historical levels for the user, e.g., as
determined using a social-gaming behavior evaluator component.

[0105] FIGS. 22A-C are of logic flow diagrams illustrating example aspects
of implementing strategic game modification based on tracking engagement
of a group of users within the OBM in some embodiments of the OBM, e.g.,
a group engagement-tracking game modification ("G-ETGM") component 2200.
In some implementations, the OBM may track events, e.g., in real-time,
occurring at a specific geographical region that may affect the online
social-gaming behavior of users within that geographical region, and/or
users major events that may affect users at a wide range of geographical
regions. For example, the OBM may detect that the aggregate engagement of
a group of users at a particular location may drop, and the drop may
coincide with an event occurring at that location (e.g., high-school
football game), and/or an event occurring at another location (e.g.,
world cup soccer game). The OBM may, in some implementations, track such
user engagement anomalies, determine inferences about the population of
users who temporarily lose engagement in the gaming apps, and determine
inferences about those users who did not lose engagement in the gaming
apps even during the time period of the event. In some implementations,
the OBM may utilize the inferences to offer rewards for
loyalty/engagement, prioritization of service and/or (e.g., in-game)
requests, offer incentives to maintain/re-attain high engagement levels,
offer products targeted at the users based on statistical estimation of
the personal characteristics of the groups of users based on their online
social-gaming behavior during such geographically-specific events, etc.

[0106] In some implementations, the OBM may identify a distinct
geographical area, e.g., 2201. The OBM may, e.g., identify 2202 a set of
Internet Protocol ("IP") addresses associated with the geographical area.
Upon identifying a set of IP addresses associated with the area, the OBM
may determine a set of user IDs associated with geographical area, e.g.,
2203, based on querying the gaming environment databases using the
identified IP addresses. The OBM may, e.g., utilize a social-gaming
behavior evaluator component (such as the example SGBE 1200 component),
to generate social-gaming activity timelines for the identified user IDs,
e.g., 2204. Further, the OBM may generate a time-varying activity level
histogram, e.g., 2205, for each user ID. For example, the OBM may
generate, for each user ID, a histogram with a period in time on the
x-axis, and frequency of activity on the y-axis. The OBM may generate a
historical aggregate activity level graph by aggregating the histograms
for the identified user IDs, e.g., 2206. The OBM may then identify
troughs, e.g., 2207, in the aggregate activity level graph (e.g., by
calculating a graph of the differentiation of the activity level graph
with respect to time, and identifying any negative spikes in the
differentiation graph, identifying time periods where activity level was
below a threshold level, or a threshold percentage of the historical
average activity level, etc.). The OBM may assign a trough ID to each of
the identified troughs in the aggregate activity level graph, e.g., 2208.
The OBM may, in some implementations, analyze the positions of the trough
compared to the time of day in the geographical region, and
neglect/eliminate, e.g., 2209, activity troughs that are expected (e.g.,
night-time, peak hours in work day, etc.). The OBM may then analyze each
activity trough remaining in the aggregate activity level graph.

[0107] In some implementations, the OBM may select, e.g., 2210, a trough
identified by a trough ID. The OBM may identify a time of the activity
trough, e.g., 2211. The OBM may initiate searches (e.g., using news
aggregators, search engines, etc.) for events that occurred during the
time period of the activity trough. For example, the OBM may attempt to
identify, e.g., 2212, a "local" event, e.g., an event that occurred
within the geographical region during the period of the activity trough.
The OBM may, in some implementations, attempt to identify, e.g., 2213, a
"global" event, e.g., an event that occurred outside of the geographical
region during the period of the activity trough. For example, the OBM may
aggregate the search results from a variety of news sources, and analyze,
e.g., using keyword matching, latent semantic indexing, etc., the
aggregated search results to identify any events recurring in the
aggregated search results. Based on the analysis, the OBM may identify a
local event and/or a global event, or not identify any event during the
time period of the activity trough. If the OBM does not find any local or
global event (e.g., 2215, option "No"), the OBM may repeat the above
procedure for a different activity trough, if there are further activity
trough identified for the geographical area (e.g., 2216, option "Yes").
If there are no further activity troughs for the geographical area (e.g.,
2216, option "No"), the OBM may repeat the above procedure for another
geographical area, if there are further geographical areas for which the
OBM can perform the above procedure (e.g., 2217, option "Yes"). If there
are no further geographical areas for which to perform the procedure
above (e.g., 2217, option "No"), the OBM may end the procedure.

[0108] In some implementations, the OBM may find a local and/or global
event during an activity trough for the aggregate activity graph of users
confined to a specific geographical area (e.g., 2215, option "Yes"). In
such implementations, the OBM may identify keywords associated with a
local event (if any) based on the results of the analysis (e.g., using
latent semantic indexing) of the aggregated search results, e.g., 2218.
the OBM may identify keywords associated with a global event (if any)
based on the results of the analysis (e.g., using latent semantic
indexing) of the aggregated search results, e.g., 2219. The OBM may
utilize the keywords obtained from analyzing the aggregated search
results to query a (virtual) product database for (virtual) items (e.g.,
physical objects, which may also include game incentives, virtual objects
to reduce the in-game difficulty levels of objects and/or game stages,
etc.) that may be offered for sale for the users in the geographical
area. For example, the OBM may identify "local" items in the product
database based on querying the database using keywords associated with
the local event, e.g., 2220, and "global" items in the products database
based on querying the database using keywords associated with the global
event, e.g., 2221. The OBM may aggregate the products search results
based on the "global keywords" to a global products list.

[0109] Upon identifying items from the products database to offer for the
users of the geographical area, the OBM may identify, e.g., 2222, the
user IDs that had low individual activity levels during the period of the
aggregate activity level trough (e.g., using a SGBE 1200 component). In
some implementations, the OBM may offer the local items (if any) and
global items from the aggregated list of global items (if any) for sale
to the user IDs identified as having low activity levels during the
aggregate activity level trough, e.g., 2223. For example, the OBM may
identify an IP address of a mobile device utilized by a user having low
activity level during the aggregate activity level trough, and send a
message (e.g., text message, SMS, e-mail message, tweet, and/or the like)
offering the items for sale (e.g., at discounted prices, combined with
in-game incentives, etc.). In some implementations, the OBM may identify
anomalous users (e.g., those who had normal/high individual activity
levels during the aggregate activity level trough), e.g., 2224. The OBM
may, in such implementations, provide, e.g., 2225, messages to the
identified users offering encouragement, loyalty rewards, in-game
credits, and/or the like. The OBM may, in some implementations, infer,
e.g., 2226, characteristics of users having normal/high individual
activity levels during an aggregate activity level trough (e.g., male,
single, student, age group, etc.). The OBM may generate keywords based on
the inferred characteristics, and query, e.g., 2227, the products
database based on the inferred-characteristics keywords and obtain
"inferred products" search results. The OBM may, in some implementations,
provide such identified products for sale to the users exhibiting
normal/high individual activity levels during the aggregate activity
level trough, e.g., 2228.

[0111] Typically, users, which may be people and/or other systems, may
engage information technology systems (e.g., computers) to facilitate
information processing. In turn, computers employ processors to process
information; such processors 2303 may be referred to as central
processing units (CPU). One form of processor is referred to as a
microprocessor. CPUs use communicative circuits to pass binary encoded
signals acting as instructions to enable various operations. These
instructions may be operational and/or data instructions containing
and/or referencing other instructions 11 and data in various processor
accessible and operable areas of memory 2329 (e.g., registers, cache
memory, random access memory, etc.). Such communicative instructions may
be stored and/or transmitted in batches (e.g., batches of instructions)
as programs and/or data components to facilitate desired operations.
These stored instruction codes, e.g., programs, may engage the CPU
circuit components and other motherboard and/or system components to
perform desired operations. One type of program is a computer operating
system, which, may be executed by CPU on a computer; the operating system
enables and facilitates users to access and operate computer information
technology and resources. Some resources that may be employed in
information technology systems include: input and output mechanisms
through which data may pass into and out of a computer; memory storage
into which data may be saved; and processors by which information may be
processed. These information technology systems may be used to collect
data for later retrieval, analysis, and manipulation, which may be
facilitated through a database program. These information technology
systems provide interfaces that allow users to access and operate various
system components.

[0113] Networks are commonly thought to comprise the interconnection and
interoperation of clients, servers, and intermediary nodes in a graph
topology. It should be noted that the term "server" as used throughout
this application refers generally to a computer, other device, program,
or combination thereof that processes and responds to the requests of
remote users across a communications network. Servers serve their
information to requesting "clients." The term "client" as used herein
refers generally to a computer, program, other device, user and/or
combination thereof that is capable of processing and making requests and
obtaining and processing any responses from servers across a
communications network. A computer, other device, program, or combination
thereof that facilitates, processes information and requests, and/or
furthers the passage of information from a source user to a destination
user is commonly referred to as a "node." Networks are generally thought
to facilitate the transfer of information from source points to
destinations. A node specifically tasked with furthering the passage of
information from a source to a destination is commonly called a "router."
There are many forms of networks such as Local Area Networks (LANs), Pico
networks, Wide Area Networks (WANs), Wireless Networks (WLANs), etc. For
example, the Internet is generally accepted as being an interconnection
of a multitude of networks whereby remote clients and servers may access
and interoperate with one another.

[0114] The OBM controller 2301 may be based on computer systems that may
comprise, but are not limited to, components such as: a computer
systemization 2302 connected to memory 2329.

Computer Systemization

[0115] A computer systemization 2302 may comprise a clock 2330, central
processing unit ("CPU(s)" and/or "processor(s)" (these terms are used
interchangeable throughout the disclosure unless noted to the contrary))
2303, a memory 2329 (e.g., a read only memory (ROM) 2306, a random access
memory (RAM) 2305, etc.), and/or an interface bus 2307, and most
frequently, although not necessarily, are all interconnected and/or
communicating through a system bus 2304 on one or more (mother)board(s)
2302 having conductive and/or otherwise transportive circuit pathways
through which instructions (e.g., binary encoded signals) may travel to
effect communications, operations, storage, etc. Optionally, the computer
systemization may be connected to an internal power source 2386.
Optionally, a cryptographic processor 2326 may be connected to the system
bus. The system clock typically has a crystal oscillator and generates a
base signal through the computer systemization's circuit pathways. The
clock is typically coupled to the system bus and various clock
multipliers that will increase or decrease the base operating frequency
for other components interconnected in the computer systemization. The
clock and various components in a computer systemization drive signals
embodying information throughout the system. Such transmission and
reception of instructions embodying information throughout a computer
systemization may be commonly referred to as communications. These
communicative instructions may further be transmitted, received, and the
cause of return and/or reply communications beyond the instant computer
systemization to: communications networks, input devices, other computer
systemizations, peripheral devices, and/or the like. Of course, any of
the above components may be connected directly to one another, connected
to the CPU, and/or organized in numerous variations employed as
exemplified by various computer systems.

[0117] Depending on the particular implementation, features of the OBM may
be achieved by implementing a microcontroller such as CAST's R8051XC2
microcontroller; Intel's MCS 51 (i.e., 8051 microcontroller); and/or the
like. Also, to implement certain features of the OBM, some feature
implementations may rely on embedded components, such as:
Application-Specific Integrated Circuit ("ASIC"), Digital Signal
Processing ("DSP"), Field Programmable Gate Array ("FPGA"), and/or the
like embedded technology. For example, any of the OBM component
collection (distributed or otherwise) and/or features may be implemented
via the microprocessor and/or via embedded components; e.g., via ASIC,
coprocessor, DSP, FPGA, and/or the like. Alternately, some
implementations of the OBM may be implemented with embedded components
that are configured and used to achieve a variety of features or signal
processing.

[0118] Depending on the particular implementation, the embedded components
may include software solutions, hardware solutions, and/or some
combination of both hardware/software solutions. For example, OBM
features discussed herein may be achieved through implementing FPGAs,
which are a semiconductor devices containing programmable logic
components called "logic blocks", and programmable interconnects, such as
the high performance FPGA Virtex series and/or the low cost Spartan
series manufactured by Xilinx. Logic blocks and interconnects can be
programmed by the customer or designer, after the FPGA is manufactured,
to implement any of the OBM features. A hierarchy of programmable
interconnects allow logic blocks to be interconnected as needed by the
OBM system designer/administrator, somewhat like a one-chip programmable
breadboard. An FPGA's logic blocks can be programmed to perform the
function of basic logic gates such as AND, and XOR, or more complex
combinational functions such as decoders or simple mathematical
functions. In most FPGAs, the logic blocks also include memory elements,
which may be simple flip-flops or more complete blocks of memory. In some
circumstances, the OBM may be developed on regular FPGAs and then
migrated into a fixed version that more resembles ASIC implementations.
Alternate or coordinating implementations may migrate OBM controller
features to a final ASIC instead of or in addition to FPGAs. Depending on
the implementation all of the aforementioned embedded components and
microprocessors may be considered the "CPU" and/or "processor" for the
OBM.

Power Source

[0119] The power source 2386 may be of any standard form for powering
small electronic circuit board devices such as the following power cells:
alkaline, lithium hydride, lithium ion, lithium polymer, nickel cadmium,
solar cells, and/or the like. Other types of AC or DC power sources may
be used as well. In the case of solar cells, in one embodiment, the case
provides an aperture through which the solar cell may capture photonic
energy. The power cell 2386 is connected to at least one of the
interconnected subsequent components of the OBM thereby providing an
electric current to all subsequent components. In one example, the power
source 2386 is connected to the system bus component 2304. In an
alternative embodiment, an outside power source 2386 is provided through
a connection across the I/O 2308 interface. For example, a USB and/or
IEEE 1394 connection carries both data and power across the connection
and is therefore a suitable source of power.

Interface Adapters

[0120] Interface bus(ses) 2307 may accept, connect, and/or communicate to
a number of interface adapters, conventionally although not necessarily
in the form of adapter cards, such as but not limited to: input output
interfaces (I/O) 2308, storage interfaces 2309, network interfaces 2310,
and/or the like. Optionally, cryptographic processor interfaces 2327
similarly may be connected to the interface bus. The interface bus
provides for the communications of interface adapters with one another as
well as with other components of the computer systemization. Interface
adapters are adapted for a compatible interface bus. Interface adapters
conventionally connect to the interface bus via a slot architecture.
Conventional slot architectures may be employed, such as, but not limited
to: Accelerated Graphics Port (AGP), Card Bus, (Extended) Industry
Standard Architecture ((E)ISA), Micro Channel Architecture (MCA), NuBus,
Peripheral Component Interconnect (Extended) (PCI(X)), PCI Express,
Personal Computer Memory Card International Association (PCMCIA), and/or
the like.

[0122] Network interfaces 2310 may accept, communicate, and/or connect to
a communications network 2313. Through a communications network 2313, the
OBM controller is accessible through remote clients 2333b (e.g.,
computers with web browsers) by users 2333a. Network interfaces may
employ connection protocols such as, but not limited to: direct connect,
Ethernet (thick, thin, twisted pair 10/100/1000 Base T, and/or the like),
Token Ring, wireless connection such as IEEE 802.11a-x, and/or the like.
Should processing requirements dictate a greater amount speed and/or
capacity, distributed network controllers (e.g., Distributed OBM),
architectures may similarly be employed to pool, load balance, and/or
otherwise increase the communicative bandwidth required by the OBM
controller. A communications network may be any one and/or the
combination of the following: a direct interconnection; the Internet; a
Local Area Network (LAN); a Metropolitan Area Network (MAN); an Operating
Missions as Nodes on the Internet (OMNI); a secured custom connection; a
Wide Area Network (WAN); a wireless network (e.g., employing protocols
such as, but not limited to a Wireless Application Protocol (WAP),
I-mode, and/or the like); and/or the like. A network interface may be
regarded as a specialized form of an input output interface. Further,
multiple network interfaces 2310 may be used to engage with various
communications network types 2313. For example, multiple network
interfaces may be employed to allow for the communication over broadcast,
multicast, and/or unicast networks.

[0126] It should be noted that although user input devices and peripheral
devices may be employed, the OBM controller may be embodied as an
embedded, dedicated, and/or monitor-less (i.e., headless) device, wherein
access would be provided over a network interface connection.

[0127] Cryptographic units such as, but not limited to, microcontrollers,
processors 2326, interfaces 2327, and/or devices 2328 may be attached,
and/or communicate with the OBM controller. A MC68HC16 microcontroller,
manufactured by Motorola Inc., may be used for and/or within
cryptographic units. The MC68HC16 microcontroller utilizes a 16-bit
multiply-and-accumulate instruction in the 16 MHz configuration and
requires less than one second to perform a 512-bit RSA private key
operation. Cryptographic units support the authentication of
communications from interacting agents, as well as allowing for anonymous
transactions. Cryptographic units may also be configured as part of CPU.
Equivalent microcontrollers and/or processors may also be used. Other
commercially available specialized cryptographic processors include: the
Broadcom's CryptoNetX and other Security Processors; nCipher's nShield,
SafeNet's Luna PCI (e.g., 7100) series; Semaphore Communications' 40 MHz
Roadrunner 184; Sun's Cryptographic Accelerators (e.g., Accelerator 6000
PCIe Board, Accelerator 500 Daughtercard); Via Nano Processor (e.g.,
L2100, L2200, U2400) line, which is capable of performing 500+ MB/s of
cryptographic instructions; VLSI Technology's 33 MHz 6868; and/or the
like.

Memory

[0128] Generally, any mechanization and/or embodiment allowing a processor
to affect the storage and/or retrieval of information is regarded as
memory 2329. However, memory is a fungible technology and resource, thus,
any number of memory embodiments may be employed in lieu of or in concert
with one another. It is to be understood that the OBM controller and/or a
computer systemization may employ various forms of memory 2329. For
example, a computer systemization may be configured wherein the
functionality of on-chip CPU memory (e.g., registers), RAM, ROM, and any
other storage devices are provided by a paper punch tape or paper punch
card mechanism; of course such an embodiment would result in an extremely
slow rate of operation. In a typical configuration, memory 2329 will
include ROM 2306, RAM 2305, and a storage device 2314. A storage device
2314 may be any conventional computer system storage. Storage devices may
include a drum; a (fixed and/or removable) magnetic disk drive; a
magneto-optical drive; an optical drive (i.e., Blueray, CD
ROM/RAM/Recordable (R)/ReWritable (RW), DVD R/RW, HD DVD R/RW etc.); an
array of devices (e.g., Redundant Array of Independent Disks (RAID));
solid state memory devices (USB memory, solid state drives (SSD), etc.);
other processor-readable storage mediums; and/or other devices of the
like. Thus, a computer systemization generally requires and makes use of
memory.

Component Collection

[0129] The memory 2329 may contain a collection of program and/or database
components and/or data such as, but not limited to: operating system
component(s) 2315 (operating system); information server component(s)
2316 (information server); user interface component(s) 2317 (user
interface); Web browser component(s) 2318 (Web browser); database(s)
2319; mail server component(s) 2321; mail client component(s) 2322;
cryptographic server component(s) 2320 (cryptographic server); the OBM
component(s) 2335; and/or the like (i.e., collectively a component
collection). These components may be stored and accessed from the storage
devices and/or from storage devices accessible through an interface bus.
Although non-conventional program components such as those in the
component collection, typically, are stored in a local storage device
2314, they may also be loaded and/or stored in memory such as: peripheral
devices, RAM, remote storage facilities through a communications network,
ROM, various forms of memory, and/or the like.

Operating System

[0130] The operating system component 2315 is an executable program
component facilitating the operation of the OBM controller. Typically,
the operating system facilitates access of I/O, network interfaces,
peripheral devices, storage devices, and/or the like. The operating
system may be a highly fault tolerant, scalable, and secure system such
as: Apple Macintosh OS X (Server); AT&T Plan 9; Be OS; Unix and Unix-like
system distributions (such as AT&T's UNIX; Berkley Software Distribution
(BSD) variations such as FreeBSD, NetBSD, OpenBSD, and/or the like; Linux
distributions such as Red Hat, Ubuntu, and/or the like); and/or the like
operating systems. However, more limited and/or less secure operating
systems also may be employed such as Apple Macintosh OS, IBM OS/2,
Microsoft COS, Microsoft Windows
2000/2003/3.1/95/98/CE/Millenium/NT/Vista/XP (Server), Palm OS, and/or
the like. An operating system may communicate to and/or with other
components in a component collection, including itself, and/or the like.
Most frequently, the operating system communicates with other program
components, user interfaces, and/or the like. For example, the operating
system may contain, communicate, generate, obtain, and/or provide program
component, system, user, and/or data communications, requests, and/or
responses. The operating system, once executed by the CPU, may enable the
interaction with communications networks, data, I/O, peripheral devices,
program components, memory, user input devices, and/or the like. The
operating system may provide communications protocols that allow the OBM
controller to communicate with other entities through a communications
network 2313. Various communication protocols may be used by the OBM
controller as a subcarrier transport mechanism for interaction, such as,
but not limited to: multicast, TCP/IP, UDP, unicast, and/or the like.

Information Server

[0131] An information server component 2316 is a stored program component
that is executed by a CPU. The information server may be a conventional
Internet information server such as, but not limited to Apache Software
Foundation's Apache, Microsoft's Internet Information Server, and/or the
like. The information server may allow for the execution of program
components through facilities such as Active Server Page (ASP), ActiveX,
(ANSI) (Objective-) C (++), C# and/or .NET, Common Gateway Interface
(CGI) scripts, dynamic (D) hypertext markup language (HTML), FLASH, Java,
JavaScript, Practical Extraction Report Language (PERL), Hypertext
Pre-Processor (PHP), pipes, Python, wireless application protocol (WAP),
WebObjects, and/or the like. The information server may support secure
communications protocols such as, but not limited to, File Transfer
Protocol (FTP); HyperText Transfer Protocol (HTTP); Secure Hypertext
Transfer Protocol (HTTPS), Secure Socket Layer (SSL), messaging protocols
(e.g., America Online (AOL) Instant Messenger (AIM), Application Exchange
(APEX), ICQ, Internet Relay Chat (IRC), Microsoft Network (MSN) Messenger
Service, Presence and Instant Messaging Protocol (PRIM), Internet
Engineering Task Force's (IETF's) Session Initiation Protocol (SIP), SIP
for Instant Messaging and Presence Leveraging Extensions (SIMPLE), open
XML-based Extensible Messaging and Presence Protocol (XMPP) (i.e., Jabber
or Open Mobile Alliance's (OMA's) Instant Messaging and Presence Service
(IMPS)), Yahoo! Instant Messenger Service, and/or the like. The
information server provides results in the form of Web pages to Web
browsers, and allows for the manipulated generation of the Web pages
through interaction with other program components. After a Domain Name
System (DNS) resolution portion of an HTTP request is resolved to a
particular information server, the information server resolves requests
for information at specified locations on the OBM controller based on the
remainder of the HTTP request. For example, a request such as
http://123.124.125.126/myInformation.html might have the IP portion of
the request "123.124.125.126" resolved by a DNS server to an information
server at that IP address; that information server might in turn further
parse the http request for the "/myInformation.html" portion of the
request and resolve it to a location in memory containing the information
"myInformation.html." Additionally, other information serving protocols
may be employed across various ports, e.g., FTP communications across
port 21, and/or the like. An information server may communicate to and/or
with other components in a component collection, including itself, and/or
facilities of the like. Most frequently, the information server
communicates with the OBM database 2319, operating systems, other program
components, user interfaces, Web browsers, and/or the like.

[0132] Access to the OBM database may be achieved through a number of
database bridge mechanisms such as through scripting languages as
enumerated below (e.g., CGI) and through inter-application communication
channels as enumerated below (e.g., CORBA, WebObjects, etc.). Any data
requests through a Web browser are parsed through the bridge mechanism
into appropriate grammars as required by the OBM. In one embodiment, the
information server would provide a Web form accessible by a Web browser.
Entries made into supplied fields in the Web form are tagged as having
been entered into the particular fields, and parsed as such. The entered
terms are then passed along with the field tags, which act to instruct
the parser to generate queries directed to appropriate tables and/or
fields. In one embodiment, the parser may generate queries in standard
SQL by instantiating a search string with the proper join/select commands
based on the tagged text entries, wherein the resulting command is
provided over the bridge mechanism to the OBM as a query. Upon generating
query results from the query, the results are passed over the bridge
mechanism, and may be parsed for formatting and generation of a new
results Web page by the bridge mechanism. Such a new results Web page is
then provided to the information server, which may supply it to the
requesting Web browser.

[0135] A user interface component 2317 is a stored program component that
is executed by a CPU. The user interface may be a conventional graphic
user interface as provided by, with, and/or atop operating systems and/or
operating environments such as already discussed. The user interface may
allow for the display, execution, interaction, manipulation, and/or
operation of program components and/or system facilities through textual
and/or graphical facilities. The user interface provides a facility
through which users may affect, interact, and/or operate a computer
system. A user interface may communicate to and/or with other components
in a component collection, including itself, and/or facilities of the
like. Most frequently, the user interface communicates with operating
systems, other program components, and/or the like. The user interface
may contain, communicate, generate, obtain, and/or provide program
component, system, user, and/or data communications, requests, and/or
responses.

Web Browser

[0136] A Web browser component 2318 is a stored program component that is
executed by a CPU. The Web browser may be a conventional hypertext
viewing application such as Microsoft Internet Explorer or Netscape
Navigator. Secure Web browsing may be supplied with 128 bit (or greater)
encryption by way of HTTPS, SSL, and/or the like. Web browsers allowing
for the execution of program components through facilities such as
ActiveX, AJAX, (D)HTML, FLASH, Java, JavaScript, web browser plug-in APIs
(e.g., FireFox, Safari Plug-in, and/or the like APIs), and/or the like.
Web browsers and like information access tools may be integrated into
PDAs, cellular telephones, and/or other mobile devices. A Web browser may
communicate to and/or with other components in a component collection,
including itself, and/or facilities of the like. Most frequently, the Web
browser communicates with information servers, operating systems,
integrated program components (e.g., plug-ins), and/or the like; e.g., it
may contain, communicate, generate, obtain, and/or provide program
component, system, user, and/or data communications, requests, and/or
responses. Of course, in place of a Web browser and information server, a
combined application may be developed to perform similar functions of
both. The combined application would similarly affect the obtaining and
the provision of information to users, user agents, and/or the like from
the OBM enabled nodes. The combined application may be nugatory on
systems employing standard Web browsers.

Mail Server

[0137] A mail server component 2321 is a stored program component that is
executed by a CPU 2303. The mail server may be a conventional Internet
mail server such as, but not limited to sendmail, Microsoft Exchange,
and/or the like. The mail server may allow for the execution of program
components through facilities such as ASP, ActiveX, (ANSI) (Objective-) C
(++), C# and/or .NET, CGI scripts, Java, JavaScript, PERL, PHP, pipes,
Python, WebObjects, and/or the like. The mail server may support
communications protocols such as, but not limited to: Internet message
access protocol (IMAP), Messaging Application Programming Interface
(MAPI)/Microsoft Exchange, post office protocol (POP3), simple mail
transfer protocol (SMTP), and/or the like. The mail server can route,
forward, and process incoming and outgoing mail messages that have been
sent, relayed and/or otherwise traversing through and/or to the OBM.

[0138] Access to the OBM mail may be achieved through a number of APIs
offered by the individual Web server components and/or the operating
system.

[0140] A mail client component 2322 is a stored program component that is
executed by a CPU 2303. The mail client may be a conventional mail
viewing application such as Apple Mail, Microsoft Entourage, Microsoft
Outlook, Microsoft Outlook Express, Mozilla, Thunderbird, and/or the
like. Mail clients may support a number of transfer protocols, such as:
IMAP, Microsoft Exchange, POP3, SMTP, and/or the like. A mail client may
communicate to and/or with other components in a component collection,
including itself, and/or facilities of the like. Most frequently, the
mail client communicates with mail servers, operating systems, other mail
clients, and/or the like; e.g., it may contain, communicate, generate,
obtain, and/or provide program component, system, user, and/or data
communications, requests, information, and/or responses. Generally, the
mail client provides a facility to compose and transmit electronic mail
messages.

Cryptographic Server

[0141] A cryptographic server component 2320 is a stored program component
that is executed by a CPU 2303, cryptographic processor 2326,
cryptographic processor interface 2327, cryptographic processor device
2328, and/or the like. Cryptographic processor interfaces will allow for
expedition of encryption and/or decryption requests by the cryptographic
component; however, the cryptographic component, alternatively, may run
on a conventional CPU. The cryptographic component allows for the
encryption and/or decryption of provided data. The cryptographic
component allows for both symmetric and asymmetric (e.g., Pretty Good
Protection (PGP)) encryption and/or decryption. The cryptographic
component may employ cryptographic techniques such as, but not limited
to: digital certificates (e.g., X.509 authentication framework), digital
signatures, dual signatures, enveloping, password access protection,
public key management, and/or the like. The cryptographic component will
facilitate numerous (encryption and/or decryption) security protocols
such as, but not limited to: checksum, Data Encryption Standard (DES),
Elliptical Curve Encryption (ECC), International Data Encryption
Algorithm (IDEA), Message Digest 5 (MD5, which is a one way hash
function), passwords, Rivest Cipher (RC5), Rijndael, RSA (which is an
Internet encryption and authentication system that uses an algorithm
developed in 1977 by Ron Rivest, Adi Shamir, and Leonard Adleman), Secure
Hash Algorithm (SHA), Secure Socket Layer (SSL), Secure Hypertext
Transfer Protocol (HTTPS), and/or the like. Employing such encryption
security protocols, the OBM may encrypt all incoming and/or outgoing
communications and may serve as node within a virtual private network
(VPN) with a wider communications network. The cryptographic component
facilitates the process of "security authorization" whereby access to a
resource is inhibited by a security protocol wherein the cryptographic
component effects authorized access to the secured resource. In addition,
the cryptographic component may provide unique identifiers of content,
e.g., employing and MD5 hash to obtain a unique signature for an digital
audio file. A cryptographic component may communicate to and/or with
other components in a component collection, including itself, and/or
facilities of the like. The cryptographic component supports encryption
schemes allowing for the secure transmission of information across a
communications network to enable the OBM component to engage in secure
transactions if so desired. The cryptographic component facilitates the
secure accessing of resources on the OBM and facilitates the access of
secured resources on remote systems; i.e., it may act as a client and/or
server of secured resources. Most frequently, the cryptographic component
communicates with information servers, operating systems, other program
components, and/or the like. The cryptographic component may contain,
communicate, generate, obtain, and/or provide program component, system,
user, and/or data communications, requests, and/or responses.

The OBM Database

[0142] The OBM database component 2319 may be embodied in a database and
its stored data. The database is a stored program component, which is
executed by the CPU; the stored program component portion configuring the
CPU to process the stored data. The database may be a conventional, fault
tolerant, relational, scalable, secure database such as Oracle or Sybase.
Relational databases are an extension of a flat file. Relational
databases consist of a series of related tables. The tables are
interconnected via a key field. Use of the key field allows the
combination of the tables by indexing against the key field; i.e., the
key fields act as dimensional pivot points for combining information from
various tables. Relationships generally identify links maintained between
tables by matching primary keys. Primary keys represent fields that
uniquely identify the rows of a table in a relational database. More
precisely, they uniquely identify rows of a table on the "one" side of a
one-to-many relationship.

[0143] Alternatively, the OBM database may be implemented using various
standard data-structures, such as an array, hash, (linked) list, struct,
structured text file (e.g., XML), table, and/or the like. Such
data-structures may be stored in memory and/or in (structured) files. In
another alternative, an object-oriented database may be used, such as
Frontier, ObjectStore, Poet, Zope, and/or the like. Object databases can
include a number of object collections that are grouped and/or linked
together by common attributes; they may be related to other object
collections by some common attributes. Object-oriented databases perform
similarly to relational databases with the exception that objects are not
just pieces of data but may have other types of functionality
encapsulated within a given object. If the OBM database is implemented as
a data-structure, the use of the OBM database 2319 may be integrated into
another component such as the OBM component 2335. Also, the database may
be implemented as a mix of data structures, objects, and relational
structures. Databases may be consolidated and/or distributed in countless
variations through standard data processing techniques. Portions of
databases, e.g., tables, may be exported and/or imported and thus
decentralized and/or integrated.

[0145] In one embodiment, the OBM database may interact with other
database systems. For example, employing a distributed database system,
queries and data access by search OBM component may treat the combination
of the OBM database, an integrated data security layer database as a
single database entity.

[0146] In one embodiment, user programs may contain various user interface
primitives, which may serve to update the OBM. Also, various accounts may
require custom database tables depending upon the environments and the
types of clients the OBM may need to serve. It should be noted that any
unique fields may be designated as a key field throughout. In an
alternative embodiment, these tables have been decentralized into their
own databases and their respective database controllers (i.e., individual
database controllers for each of the above tables). Employing standard
data processing techniques, one may further distribute the databases over
several computer systemizations and/or storage devices. Similarly,
configurations of the decentralized database controllers may be varied by
consolidating and/or distributing the various database components
2319a-o. The OBM may be configured to keep track of various settings,
inputs, and parameters via database controllers.

[0147] The OBM database may communicate to and/or with other components in
a component collection, including itself, and/or facilities of the like.
Most frequently, the OBM database communicates with the OBM component,
other program components, and/or the like. The database may contain,
retain, and provide information regarding other nodes and data.

The OBMs

[0148] The OBM component 2335 is a stored program component that is
executed by a CPU. In one embodiment, the OBM component incorporates any
and/or all combinations of the aspects of the OBM discussed in the
previous figures. As such, the OBM affects accessing, obtaining and the
provision of information, services, transactions, and/or the like across
various communications networks.

[0151] The structure and/or operation of any of the OBM node controller
components may be combined, consolidated, and/or distributed in any
number of ways to facilitate development and/or deployment. Similarly,
the component collection may be combined in any number of ways to
facilitate deployment and/or development. To accomplish this, one may
integrate the components into a common code base or in a facility that
can dynamically load the components on demand in an integrated fashion.

[0152] The component collection may be consolidated and/or distributed in
countless variations through standard data processing and/or development
techniques. Multiple instances of any one of the program components in
the program component collection may be instantiated on a single node,
and/or across numerous nodes to improve performance through
load-balancing and/or data-processing techniques. Furthermore, single
instances may also be distributed across multiple controllers and/or
storage devices; e.g., databases. All program component instances and
controllers working in concert may do so through standard data processing
communication techniques. For example, OBM server(s) and database(s) may
all be localized within a single computing terminal. As another example,
the OBM components may be localized within one or more entities (e.g.,
hospitals, pharmaceutical companies etc.) involved in coordinated patient
management.

[0153] The configuration of the OBM controller will depend on the context
of system deployment. Factors such as, but not limited to, the budget,
capacity, location, and/or use of the underlying hardware resources may
affect deployment requirements and configuration. Regardless of if the
configuration results in more consolidated and/or integrated program
components, results in a more distributed series of program components,
and/or results in some combination between a consolidated and distributed
configuration, data may be communicated, obtained, and/or provided.
Instances of components consolidated into a common code base from the
program component collection may communicate, obtain, and/or provide
data. This may be accomplished through intra-application data processing
communication techniques such as, but not limited to: data referencing
(e.g., pointers), internal messaging, object instance variable
communication, shared memory space, variable passing, and/or the like.

[0154] If component collection components are discrete, separate, and/or
external to one another, then communicating, obtaining, and/or providing
data with and/or to other component components may be accomplished
through inter-application data processing communication techniques such
as, but not limited to: Application Program Interfaces (API) information
passage; (distributed) Component Object Model ((D)COM), (Distributed)
Object Linking and Embedding ((D)OLE), and/or the like), Common Object
Request Broker Architecture (CORBA), local and remote application program
interfaces Jini, Remote Method Invocation (RMI), SOAP, process pipes,
shared files, and/or the like. Messages sent between discrete component
components for inter-application communication or within memory spaces of
a singular component for intra-application communication may be
facilitated through the creation and parsing of a grammar. A grammar may
be developed by using standard development tools such as lex, yacc, XML,
and/or the like, which allow for grammar generation and parsing
functionality, which in turn may form the basis of communication messages
within and between components. For example, a grammar may be arranged to
recognize the tokens of an HTTP post command, e.g.:

TABLE-US-00026
w3c -post http://... Value1

[0155] where Value1 is discerned as being a parameter because "http://" is
part of the grammar syntax, and what follows is considered part of the
post value. Similarly, with such a grammar, a variable "Value1" may be
inserted into an "http://" post command and then sent. The grammar syntax
itself may be presented as structured data that is interpreted and/or
other wise used to generate the parsing mechanism (e.g., a syntax
description text file as processed by lex, yacc, etc.). Also, once the
parsing mechanism is generated and/or instantiated, it itself may process
and/or parse structured data such as, but not limited to: character
(e.g., tab) delineated text, HTML, structured text streams, XML, and/or
the like structured data. In another embodiment, inter-application data
processing protocols themselves may have integrated and/or readily
available parsers (e.g., the SOAP parser) that may be employed to parse
communications data. Further, the parsing grammar may be used beyond
message parsing, but may also be used to parse: databases, data
collections, data stores, structured data, and/or the like. Again, the
desired configuration will depend upon the context, environment, and
requirements of system deployment.

[0170] A3. The method of embodiment 1, further comprising: [0171]
generating a constraint of service order upon determining that at least
one virtual security clearance flag was generated based on the
comparison; and [0172] providing the constraint of service order.

[0192] A10. The system of embodiment 8, wherein the processor further
issues instructions to: [0193] generate a constraint of service order
upon determining that at least one virtual security clearance flag was
generated based on the comparison; and [0194] provide the constraint of
service order.

[0195] A11. The system of embodiment 8, wherein the virtual security
clearance request is generated upon obtaining a user online gaming action
input.

[0196] A12. The system of embodiment 10, wherein the constraint of service
order includes orders on modifying an online gaming experience for a
user.

[0197] A13. The system of embodiment 10, wherein the constraint of service
order includes an online gaming activity report based on the
social-gaming activity timeline.

[0198] A14. The system of embodiment 12, wherein the orders on modifying
the online gaming experience for the user include locking the user out of
the online gaming experience.

[0212] A17. The medium of embodiment 15, the medium further storing
instructions to: [0213] generate a constraint of service order upon
determining that at least one virtual security clearance flag was
generated based on the comparison; and [0214] provide the constraint of
service order.

[0216] A19. The medium of embodiment 17, wherein the constraint of service
order includes orders on modifying an online gaming experience for a
user.

[0217] A20. The medium of embodiment 17, wherein the constraint of service
order includes an online gaming activity report based on the
social-gaming activity timeline.

[0218] A21. The medium of embodiment 19, wherein the orders on modifying
the online gaming experience for the user include locking the user out of
the online gaming experience.

[0219] B1. A processor-implemented customer service request evaluation
method, comprising: [0220] obtaining a customer service request from a
user; [0221] obtaining, for processing the customer service request, at
least: [0222] user social data including graph data identifying
co-users, social networking action identifiers and associated social
networking action timestamps; [0223] user online gaming pattern data
including gaming action identifiers and associated gaming action
timestamps; and [0224] customer service request evaluation rules and
associated request evaluation score thresholds; [0225] generating, via
a processor, social-gaming activity timelines for the user and the
co-users using the gaming action identifiers and the associated gaming
action timestamps, as well as the social networking action identifiers
and the associated social networking action timestamps; [0226] generating
a social-gaming activity thread for the user using the social-gaming
activity timelines for the user and the co-users; [0227] calculating
customer service request evaluation rule scores by applying the customer
service request evaluation rules to the generated social-gaming activity
thread for the user; [0228] comparing each customer service request
evaluation rule score to its associated request evaluation score
threshold to generate request evaluation flags; and [0229] determining
whether to process the customer service request based on whether any
request evaluation flags were generated.

[0230] B2. The method of embodiment 1, further comprising: [0231]
generating a constraint of service order, upon determining that a request
evaluation flags was generated; and [0232] providing a notification that
the customer service request is denied.

[0233] B3. The method of embodiment 2, further comprising: [0234]
providing, for a law enforcement agency, the constraint of service order
and the social-gaming activity thread for the user.

[0235] B4. The method of embodiment 2, further comprising: [0236]
terminating a user gaming session of the user, upon generating the
constraint of service order.

[0237] B5. The method of embodiment 2, further comprising: [0238]
modifying an online gaming experience of the user based on the customer
service request evaluation rule scores.

[0239] B6. The method of embodiment 1, further comprising: [0240]
calculating a customer service request priority score associated with the
customer service request using the customer service request evaluation
rule scores, upon determining that no request evaluation flags were
generated; and [0241] storing the customer service request along with the
customer service request priority score and a customer service request
timestamp in a service request queue of such customer service requests.

[0242] B7. The method of embodiment 6, further comprising: [0243]
obtaining a notification to process one of the customer service requests
in the service request queue; and [0244] identifying one of the customer
service requests in the service request queue to provide for processing,
based on the customer service request priority scores and the customer
service request timestamps; and [0245] providing the identified customer
service request for processing.

[0246] B8. A customer service request evaluation system, comprising:

[0247] a memory; and

[0248] a processor disposed in communication with the memory and
configured to issue processing instructions stored in the memory, wherein
the processor issues instructions to: [0249] obtain a customer service
request from a user; [0250] obtain, for processing the customer service
request, at least: [0251] user social data including graph data
identifying co-users, social networking action identifiers and associated
social networking action timestamps; [0252] user online gaming pattern
data including gaming action identifiers and associated gaming action
timestamps; and [0253] customer service request evaluation rules and
associated request evaluation score thresholds; [0254] generate
social-gaming activity timelines for the user and the co-users using the
gaming action identifiers and the associated gaming action timestamps, as
well as the social networking action identifiers and the associated
social networking action timestamps; [0255] generate a social-gaming
activity thread for the user using the social-gaming activity timelines
for the user and the co-users; [0256] calculate customer service request
evaluation rule scores by applying the customer service request
evaluation rules to the generated social-gaming activity thread for the
user; [0257] compare each customer service request evaluation rule score
to its associated request evaluation score threshold to generate request
evaluation flags; and [0258] determine whether to process the customer
service request based on whether any request evaluation flags were
generated.

[0259] B9. The system of embodiment 8, wherein the processor further
issues instructions to: [0260] generate a constraint of service order,
upon determining that a request evaluation flags was generated; and
[0261] provide a notification that the customer service request is
denied.

[0262] B10. The system of embodiment 9, wherein the processor further
issues instructions to: [0263] provide, for a law enforcement agency,
the constraint of service order and the social-gaming activity thread for
the user.

[0264] B11. The system of embodiment 9, wherein the processor further
issues instructions to: [0265] terminate a user gaming session of the
user, upon generating the constraint of service order.

[0266] B12. The system of embodiment 9, wherein the processor further
issues instructions to: [0267] modify an online gaming experience of
the user based on the customer service request evaluation rule scores.

[0268] B13. The system of embodiment 8, wherein the processor further
issues instructions to: [0269] calculate a customer service request
priority score associated with the customer service request using the
customer service request evaluation rule scores, upon determining that no
request evaluation flags were generated; and [0270] store the customer
service request along with the customer service request priority score
and a customer service request timestamp in a service request queue of
such customer service requests.

[0271] B14. The system of embodiment 13, wherein the processor further
issues instructions to: [0272] obtain a notification to process one of
the customer service requests in the service request queue; and [0273]
identify one of the customer service requests in the service request
queue to provide for processing, based on the customer service request
priority scores and the customer service request timestamps; and [0274]
provide the identified customer service request for processing.

[0275] B15. A processor-readable tangible medium storing
processor-issuable customer service request evaluation instructions to:
[0276] obtain a customer service request from a user; [0277] obtain, for
processing the customer service request, at least: [0278] user social
data including graph data identifying co-users, social networking action
identifiers and associated social networking action timestamps; [0279]
user online gaming pattern data including gaming action identifiers and
associated gaming action timestamps; and [0280] customer service request
evaluation rules and associated request evaluation score thresholds;
[0281] generate social-gaming activity timelines for the user and the
co-users using the gaming action identifiers and the associated gaming
action timestamps, as well as the social networking action identifiers
and the associated social networking action timestamps; [0282] generate a
social-gaming activity thread for the user using the social-gaming
activity timelines for the user and the co-users; [0283] calculate
customer service request evaluation rule scores by applying the customer
service request evaluation rules to the generated social-gaming activity
thread for the user; [0284] compare each customer service request
evaluation rule score to its associated request evaluation score
threshold to generate request evaluation flags; and [0285] determine
whether to process the customer service request based on whether any
request evaluation flags were generated.

[0286] B16. The medium of embodiment 15, the medium further storing
instructions to: [0287] generate a constraint of service order, upon
determining that a request evaluation flags was generated; and [0288]
provide a notification that the customer service request is denied.

[0289] B17. The medium of embodiment 16, the medium further storing
instructions to: [0290] provide, for a law enforcement agency, the
constraint of service order and the social-gaming activity thread for the
user.

[0291] B18. The medium of embodiment 16, the medium further storing
instructions to: [0292] terminate a user gaming session of the user,
upon generating the constraint of service order.

[0293] B19. The medium of embodiment 16, the medium further storing
instructions to: [0294] modify an online gaming experience of the user
based on the customer service request evaluation rule scores.

[0295] B20. The medium of embodiment 15, the medium further storing
instructions to: [0296] calculate a customer service request priority
score associated with the customer service request using the customer
service request evaluation rule scores, upon determining that no request
evaluation flags were generated; and [0297] store the customer service
request along with the customer service request priority score and a
customer service request timestamp in a service request queue of such
customer service requests.

[0298] B21. The medium of embodiment 20, the medium further storing
instructions to: [0299] obtain a notification to process one of the
customer service requests in the service request queue; and [0300]
identify one of the customer service requests in the service request
queue to provide for processing, based on the customer service request
priority scores and the customer service request timestamps; and [0301]
provide the identified customer service request for processing.

[0302] C1. A processor-implemented live online game testing method,
comprising: [0303] providing, in response to a gaming app request from
a user, a gaming app including a test game feature for the user; [0304]
obtaining user social graph data identifying co-users of the user; [0305]
obtaining, upon providing the gaming app, at least: [0306] online gaming
pattern data, for the users and the co-users, including gaming action
identifiers and their associated gaming action timestamps; [0307] user
online social activity data, for the users and the co-users, including
social networking action identifiers and their associated social
networking action timestamps; and [0308] game feature adoption evaluation
instructions; [0309] generating, via a processor, social-gaming
activity timelines for the users and the co-users using the gaming action
identifiers and the associated gaming action timestamps, as well as the
social networking action identifiers and the associated social networking
action timestamps; [0310] calculating game feature adoption scores by
applying the game feature adoption evaluation instructions to the
generated social-gaming activity timelines; and [0311] providing the game
feature adoption scores. [0312] C2. The method of embodiment 1, further
comprising: [0313] identifying a subset of the co-users for whom to
provide game feature testing invitations, based on the social-gaming
activity timelines for the co-users; and [0314] providing game feature
testing invitations to the subset of the co-users.

[0315] C3. The method of embodiment 1, further comprising: [0316]
providing an option for the user to select a subset of the co-users for
whom to provide game feature testing invitations; [0317] obtaining a user
selection of the subset of the co-users for whom to provide game feature
testing invitations; and [0318] providing game feature testing
invitations to the selected subset of the co-users.

[0319] C4. The method of embodiment 2, further comprising: [0320]
obtaining invitation acceptance notifications from a subset of the
co-users; and [0321] providing gaming apps including a new test game
feature for the co-users from whom invitation acceptance notifications
were obtained.

[0322] C5. The method of embodiment 1, wherein the test game feature is a
modified gaming difficulty level.

[0323] C6. The method of embodiment 1, wherein the test game feature is a
modified product purchase price.

[0327] a processor disposed in communication with the memory and
configured to issue processing instructions stored in the memory, wherein
the processor issues instructions to: [0328] provide, in response to a
gaming app request from a user, a gaming app including a test game
feature for the user; [0329] obtain user social graph data identifying
co-users of the user; [0330] obtain, upon providing the gaming app, at
least: [0331] online gaming pattern data, for the users and the
co-users, including gaming action identifiers and their associated gaming
action timestamps; [0332] user online social activity data, for the users
and the co-users, including social networking action identifiers and
their associated social networking action timestamps; and [0333] game
feature adoption evaluation instructions; [0334] generate social-gaming
activity timelines for the users and the co-users using the gaming action
identifiers and the associated gaming action timestamps, as well as the
social networking action identifiers and the associated social networking
action timestamps; [0335] calculate game feature adoption scores by
applying the game feature adoption evaluation instructions to the
generated social-gaming activity timelines; and [0336] provide the game
feature adoption scores.

[0337] C9. The system of embodiment 8, wherein the processor further
issues instructions to: [0338] identify a subset of the co-users for
whom to provide game feature testing invitations, based on the
social-gaming activity timelines for the co-users; and [0339] provide
game feature testing invitations to the subset of the co-users.

[0340] C10. The system of embodiment 8, wherein the processor further
issues instructions to: [0341] provide an option for the user to select
a subset of the co-users for whom to provide game feature testing
invitations; [0342] obtain a user selection of the subset of the co-users
for whom to provide game feature testing invitations; and [0343] provide
game feature testing invitations to the selected subset of the co-users.

[0344] C11. The system of embodiment 9, wherein the processor further
issues instructions to: [0345] obtain invitation acceptance
notifications from a subset of the co-users; and [0346] provide gaming
apps including a new test game feature for the co-users from whom
invitation acceptance notifications were obtained.

[0347] C12. The system of embodiment 8, wherein the test game feature is a
modified gaming difficulty level.

[0348] C13. The system of embodiment 8, wherein the test game feature is a
modified product purchase price.

[0349] C14. The system of embodiment 13, wherein the modified product
purchase price pertains to an in-game virtual product.

[0350] C15. A processor-readable tangible medium storing
processor-issuable live online game testing instructions to: [0351]
provide, in response to a gaming app request from a user, a gaming app
including a test game feature for the user; [0352] obtain user social
graph data identifying co-users of the user; [0353] obtain, upon
providing the gaming app, at least: [0354] online gaming pattern data,
for the users and the co-users, including gaming action identifiers and
their associated gaming action timestamps; [0355] user online social
activity data, for the users and the co-users, including social
networking action identifiers and their associated social networking
action timestamps; and [0356] game feature adoption evaluation
instructions; [0357] generate social-gaming activity timelines for the
users and the co-users using the gaming action identifiers and the
associated gaming action timestamps, as well as the social networking
action identifiers and the associated social networking action
timestamps; [0358] calculate game feature adoption scores by applying the
game feature adoption evaluation instructions to the generated
social-gaming activity timelines; and [0359] provide the game feature
adoption scores.

[0360] C16. The medium of embodiment 15, the medium further storing
instructions to: [0361] identify a subset of the co-users for whom to
provide game feature testing invitations, based on the social-gaming
activity timelines for the co-users; and [0362] provide game feature
testing invitations to the subset of the co-users.

[0363] C17. The medium of embodiment 15, the medium further storing
instructions to: [0364] provide an option for the user to select a
subset of the co-users for whom to provide game feature testing
invitations; [0365] obtain a user selection of the subset of the co-users
for whom to provide game feature testing invitations; and [0366] provide
game feature testing invitations to the selected subset of the co-users.

[0367] C18. The medium of embodiment 16, the medium further storing
instructions to: [0368] obtain invitation acceptance notifications from
a subset of the co-users; and [0369] provide gaming apps including a new
test game feature for the co-users from whom invitation acceptance
notifications were obtained.

[0370] C19. The medium of embodiment 15, wherein the test game feature is
a modified gaming difficulty level.

[0371] C20. The medium of embodiment 15, wherein the test game feature is
a modified product purchase price.

[0373] D1. A processor-implemented group engagement tracking game
modification method, comprising: [0374] obtaining, for a group of users
within a geographical region, at least: [0375] user online gaming
pattern data including gaming action identifiers and their associated
gaming action timestamps; and [0376] user online social activity data
including social networking action identifiers and their associated
social networking action timestamps; [0377] generating, via a
processor, individual social-gaming activity timelines for the users
using the gaming action identifiers and the associated gaming action
timestamps, as well as the social networking action identifiers and the
associated social networking action timestamps; [0378] calculating
individual time-varying activity level graphs for the users using the
individual social-gaming activity timelines; [0379] calculating a
aggregate activity level graph by aggregating the individual time-varying
activity level graphs; [0380] identifying an activity trough in the
aggregate activity level graph; and [0381] identifying an event in the
geographical region during a time period corresponding to the activity
level trough.

[0382] D2. The method of embodiment 1, wherein identifying an event in the
geographical region comprises: [0383] obtaining aggregated search
results for events in the geographical region during a time period
corresponding to the activity level trough; [0384] parsing the aggregated
search results; and [0385] identifying keywords corresponding to the
event based on parsing the aggregated search results.

[0386] D3. The method of embodiment 2, further comprising: [0387]
querying a product database for sale items based on the identified
keywords; [0388] obtaining product results based on the query; [0389]
identifying a subset of the users whose individual time-varying activity
level graphs include an activity level trough during the time period
corresponding to the activity level trough in the aggregate activity
level graph; and [0390] providing an advertisement for a product from the
product results for the identified subset of the users.

[0391] D4. The method of embodiment 2, wherein the product is an in-game
virtual product.

[0392] D5. The method of embodiment 1, further comprising: [0393]
identifying a subset of the users whose individual time-varying activity
level graphs do not include an activity level trough during the time
period corresponding to the activity level trough in the aggregate
activity level graph; and [0394] providing an in-game incentive for the
identified subset of the users.

[0395] D6. The method of embodiment 5, wherein the in-game incentive
includes an in-game virtual product.

[0396] D7. The method of embodiment 5, further comprising: [0397]
inferring a personal characteristic of the subset of the users; and
[0398] providing an incentive for the subset of the users based on the
personal characteristic.

[0399] D8. A group engagement tracking game modification system,
comprising:

[0400] a memory; and

[0401] a processor disposed in communication with the memory and
configured to issue processing instructions stored in the memory, wherein
the processor issues instructions to: [0402] obtain, for a group of
users within a geographical region, at least: [0403] user online gaming
pattern data including gaming action identifiers and their associated
gaming action timestamps; and [0404] user online social activity data
including social networking action identifiers and their associated
social networking action timestamps; [0405] generate individual
social-gaming activity timelines for the users using the gaming action
identifiers and the associated gaming action timestamps, as well as the
social networking action identifiers and the associated social networking
action timestamps; [0406] calculate individual time-varying activity
level graphs for the users using the individual social-gaming activity
timelines; [0407] calculate a aggregate activity level graph by
aggregating the individual time-varying activity level graphs; [0408]
identify an activity trough in the aggregate activity level graph; and
[0409] identify an event in the geographical region during a time period
corresponding to the activity level trough.

[0410] D9. The system of embodiment 8, wherein identifying an event in the
geographical region comprises: [0411] obtain aggregated search results
for events in the geographical region during a time period corresponding
to the activity level trough; [0412] parse the aggregated search results;
and [0413] identify keywords corresponding to the event based on parsing
the aggregated search results.

[0414] D10. The system of embodiment 9, wherein the processor further
issues instructions to: [0415] query a product database for sale items
based on the identified keywords; [0416] obtain product results based on
the query; [0417] identify a subset of the users whose individual
time-varying activity level graphs include an activity level trough
during the time period corresponding to the activity level trough in the
aggregate activity level graph; and [0418] provide an advertisement for a
product from the product results for the identified subset of the users.

[0419] D11. The system of embodiment 9, wherein the product is an in-game
virtual product.

[0420] D12. The system of embodiment 8, wherein the processor further
issues instructions to: [0421] identify a subset of the users whose
individual time-varying activity level graphs do not include an activity
level trough during the time period corresponding to the activity level
trough in the aggregate activity level graph; and [0422] provide an
in-game incentive for the identified subset of the users.

[0423] D13. The system of embodiment 12, wherein the in-game incentive
includes an in-game virtual product.

[0424] D14. The system of embodiment 12, wherein the processor further
issues instructions to: [0425] infer a personal characteristic of the
subset of the users; and [0426] provide an incentive for the subset of
the users based on the personal characteristic.

[0427] D15. A processor-readable tangible medium storing
processor-issuable group engagement tracking game modification
instructions to: [0428] obtain, for a group of users within a
geographical region, at least: [0429] user online gaming pattern data
including gaming action identifiers and their associated gaming action
timestamps; and [0430] user online social activity data including social
networking action identifiers and their associated social networking
action timestamps; [0431] generate individual social-gaming activity
timelines for the users using the gaming action identifiers and the
associated gaming action timestamps, as well as the social networking
action identifiers and the associated social networking action
timestamps; [0432] calculate individual time-varying activity level
graphs for the users using the individual social-gaming activity
timelines; [0433] calculate a aggregate activity level graph by
aggregating the individual time-varying activity level graphs; [0434]
identify an activity trough in the aggregate activity level graph; and
[0435] identify an event in the geographical region during a time period
corresponding to the activity level trough.

[0436] D16. The medium of embodiment 15, wherein identifying an event in
the geographical region comprises: [0437] obtain aggregated search
results for events in the geographical region during a time period
corresponding to the activity level trough; [0438] parse the aggregated
search results; and [0439] identify keywords corresponding to the event
based on parsing the aggregated search results.

[0440] D17. The medium of embodiment 16, the medium further storing
instructions to: [0441] query a product database for sale items based
on the identified keywords; [0442] obtain product results based on the
query; [0443] identify a subset of the users whose individual
time-varying activity level graphs include an activity level trough
during the time period corresponding to the activity level trough in the
aggregate activity level graph; and [0444] provide an advertisement for a
product from the product results for the identified subset of the users.

[0445] D18. The medium of embodiment 16, wherein the product is an in-game
virtual product.

[0446] D19. The medium of embodiment 15, the medium further storing
instructions to: [0447] identify a subset of the users whose individual
time-varying activity level graphs do not include an activity level
trough during the time period corresponding to the activity level trough
in the aggregate activity level graph; and [0448] provide an in-game
incentive for the identified subset of the users.

[0449] D20. The medium of embodiment 19, wherein the in-game incentive
includes an in-game virtual product.

[0450] D21. The medium of embodiment 19, the medium further storing
instructions to: [0451] infer a personal characteristic of the subset
of the users; and [0452] provide an incentive for the subset of the users
based on the personal characteristic.

[0453] In order to address various issues and advance the art, the
entirety of this application for APPARATUSES, METHODS AND SYSTEMS FOR A
LIVE ONLINE GAME TESTER (including the Cover Page, Title, Headings,
Field, Background, Summary, Brief Description of the Drawings, Detailed
Description, Claims, Abstract, Figures, Appendices and/or otherwise)
shows, by way of illustration, various embodiments in which the claimed
invention(s) may be practiced. The advantages and features of the
application are of a representative sample of embodiments only, and are
not exhaustive and/or exclusive. They are presented only to assist in
understanding and teach the claimed principles. It should be understood
that they are not representative of all claimed inventions. As such,
certain aspects of the disclosure have not been discussed herein. That
alternate embodiments may not have been presented for a specific portion
of the invention or that further undescribed alternate embodiments may be
available for a portion is not to be considered a disclaimer of those
alternate embodiments. It will be appreciated that many of those
undescribed embodiments incorporate the same principles of the invention
and others are equivalent. Thus, it is to be understood that other
embodiments may be utilized and functional, logical, organizational,
structural and/or topological modifications may be made without departing
from the scope and/or spirit of the disclosure. As such, all examples
and/or embodiments are deemed to be non-limiting throughout this
disclosure. Also, no inference should be drawn regarding those
embodiments discussed herein relative to those not discussed herein other
than it is as such for purposes of reducing space and repetition. For
instance, it is to be understood that the logical and/or topological
structure of any combination of any program components (a component
collection), other components and/or any present feature sets as
described in the figures and/or throughout are not limited to a fixed
operating order and/or arrangement, but rather, any disclosed order is
exemplary and all equivalents, regardless of order, are contemplated by
the disclosure. Furthermore, it is to be understood that such features
are not limited to serial execution, but rather, any number of threads,
processes, services, servers, and/or the like that may execute
asynchronously, concurrently, in parallel, simultaneously, synchronously,
and/or the like are contemplated by the disclosure. As such, some of
these features may be mutually contradictory, in that they cannot be
simultaneously present in a single embodiment. Similarly, some features
are applicable to one aspect of the invention, and inapplicable to
others. In addition, the disclosure includes other inventions not
presently claimed. Applicant reserves all rights in those presently
unclaimed inventions including the right to claim such inventions, file
additional applications, continuations, continuations in part, divisions,
and/or the like thereof. As such, it should be understood that
advantages, embodiments, examples, functional, features, logical,
organizational, structural, topological, and/or other aspects of the
disclosure are not to be considered limitations on the disclosure as
defined by the claims or limitations on equivalents to the claims. It is
to be understood that, depending on the particular needs of the OBM
and/or characteristics of the hardware, software, network framework,
monetization model and/or the like, various embodiments of the OBM may be
implemented that enable a great deal of flexibility and customization. It
is to be understood that, depending on the particular needs of the OBM
and/or characteristics of the hardware, software, network framework,
monetization model and/or the like, various embodiments of the OBM may be
implemented that enable a great deal of flexibility and customization.
The instant disclosure discusses example implementations of the OBM
within the context of user online behavior monitoring. However, it is to
be understood that the system described herein can be readily configured
for a wide range of other applications and/or implementations. For
example, implementations of the OBM can be configured to operate within
the context of network security, online productivity collaboration,
online resource management, and/or the like. It is to be understood that
the OBM may be further adapted to other implementations.