# Patent

## Title
Tag latency monitoring and control system for enhanced web page performance

## Abstract

Embodiments are directed towards employing a plurality of tag states to control tag suspension based on an asynchronous process that proactively monitors tag performance, response times, and latency. Tags may be in one of multiple states. Tags in a NORMAL state or a FLAGGED state may be enabled for deployment, and tags in a SUSPENSION A state or a SUSPENSION B state may be blocked from deployment. A tag's state may change based on monitoring the tag's latency to determine if latent events occur. Tag latency may be asynchronously monitored independent of web page requests. If latent events occur, then the tag's state may change from NORMAL to FLAGGED, from FLAGGED to SUSPENSION A, or from SUSPENSION B to SUSPENSION_A. If non-latent events occur, then the tag's state may change from SUSPENSION B to FLAGGED or from FLAGGED to NORMAL, while a tag's state may change from SUSPENSION_A to SUSPENSION_B after a predetermined time period.

## Background
CROSS-REFERENCE TO RELATED APPLICATIONS
This application is the national stage of International Patent Application No. PCT/US2013/050867, having an international filing date of Jul. 17, 2013, which claims priority to U.S. patent application Ser. No. 13/554,500, filed on Jul. 20, 2012, now U.S. Pat. No. 8,706,871, entitled “TAG LATENCY MONITORING AND CONTROL SYSTEM FOR ENHANCED WEB PAGE PERFORMANCE”, the entire contents of which are incorporated herein by reference.
TECHNICAL FIELD
The present invention relates generally to tag management, and more particularly, but not exclusively to employing a plurality of tag states to control tag suspension based on an asynchronous process designed to proactively monitor tag latency.
BACKGROUND
Today, many websites include third party services that are separate from the website itself. For example, a website may include third party advertisements, help chat sessions, monitoring services, or the like. Typically, a third party may sell its services to a website such that when a user visits a specific web page, the web page loads with the third party service. Sometimes loading the third party service may include executing code for the third party service from a remote location. However, if the third party service is slow or unresponsive, then loading the web page may be slowed or the web page may be prevented from completely loading at all. Thus, it is with respect to these considerations and others that the invention has been made.



BRIEF DESCRIPTION OF THE DRAWINGS
Non-limiting and non-exhaustive embodiments of the present invention are described with reference to the following drawings. In the drawings, like reference numerals refer to like parts throughout the various figures unless otherwise specified.
For a better understanding of the present invention, reference will be made to the following Detailed Description, which is to be read in association with the accompanying drawings, wherein:
FIG. 1 is a system diagram of an environment in which embodiments of the invention may be implemented;
FIG. 2 shows an embodiment of a client device that may be included in a system such as that shown in FIG. 1;
FIG. 3 shows an embodiment of a network device that may be included in a system such as that shown in FIG. 1;
FIG. 4 illustrates a logical flow diagram generally showing one embodiment of an overview process for changing a tag state based on asynchronous monitoring of the tag's latency and enabling the tag for deployment based on a state of the tag;
FIG. 5 illustrates a logical flow diagram generally showing one embodiment of a process for changing a tag state based on a latent event of the tag and a current state of the tag;
FIG. 6 illustrates a logical flow diagram generally showing one embodiment of a process for changing a tag state based on a non-latent event of the tag and a current state of the tag;
FIG. 7 illustrates a logical flow diagram generally showing one embodiment of a process for employing a tag in one of a plurality of states and changing the tag state based on latent or non-latent event;
FIG. 8 shows one embodiment of a use case illustrating graphical representation of a plurality of tag states and events that may trigger a state change;
FIGS. 9A-9B illustrate a logical flow diagram generally showing an alternative embodiment of a process for employing a tag in one of a plurality of states and changing the tag state based on tag latency;
FIG. 10 shows an alternative embodiment of a use case illustrating graphical representation of a plurality of tag states and events that may trigger a state change; and
FIG. 11 shows one embodiment of a use case illustrating a system diagram of a system that may be utilized to monitor tag latency and control tag state changes and deployment.



DETAILED DESCRIPTION
Throughout the specification and claims, the following terms take the meanings explicitly associated herein, unless the context clearly dictates otherwise. The phrase “in one embodiment” as used herein does not necessarily refer to the same embodiment, though it may. Furthermore, the phrase “in another embodiment” as used herein does not necessarily refer to a different embodiment, although it may. Thus, as described below, various embodiments of the invention may be readily combined, without departing from the scope or spirit of the invention.
In addition, as used herein, the term “or” is an inclusive “or” operator, and is equivalent to the term “and/or,” unless the context clearly dictates otherwise. The term “based on” is not exclusive and allows for being based on additional factors not described, unless the context clearly dictates otherwise. In addition, throughout the specification, the meaning of “a,” “an,” and “the” include plural references. The meaning of “in” includes “in” and “on.”
As used herein, the term “tag” generally refers to code that may be injected into a web page using a third party solution at any point during the presentation of the web page. In some embodiments, a third party solution may reference a code provider that is separate from the host of the web page. In at least one embodiment, loading a tag into a web page may also be referred to as deploying the tag. In some embodiments, the presentations of a web page may be provided when a visitor visits a website or performs an on page action.
As used herein, the term “tag latency” generally refers to a time from when a tag is requested to when a server response is received based on the tag request. In at least one embodiment, the tag latency may be based on a time from when a tag is requested to when the complete tag is deployed. In some embodiments, the tag latency may be based on a cumulative response time of each component of the tag, including any additional code or resources required by the tag component. In other embodiments, the tag latency may be based on a longest response time of a component of a plurality of components of the tag. In another embodiment, the tag latency may be based on an error message received in response to the tag request, such as, for example, a server response with an error code of 400-500. In some embodiments, the tag latency may be a time from when a tag is requested to when a server response error message is received.
As used herein, the term “latent event” refers to a result of monitoring the tag latency, where the tag latency is greater than a maximum time latency threshold. On the contrary, as used herein, the term “non-latent event” refers to a result of monitoring the tag latency, where the tag latency is less than a maximum time latency threshold. In at least one embodiment, the maximum time latency threshold may be determined and/or modified by a user (such as a host of the website for deploying a tag). In some embodiments, the maximum time latency threshold may be based on a desired web page load time, an average tag load time, or the like.
The following briefly describes embodiments of the invention in order to provide a basic understanding of some aspects of the invention. This brief description is not intended as an extensive overview. It is not intended to identify key or critical elements, or to delineate or otherwise narrow the scope. Its purpose is merely to present some concepts in a simplified form as a prelude to the more detailed description that is presented later.
Briefly stated, various embodiments are directed to employing a plurality of tag states to control tag suspension based on an asynchronous process designed to proactively monitor tag performance and measure response times. In some embodiments, tag latency may be monitored and/or measured to determine a tag's performance and/or response time. In at least one embodiment, a user may register with a service to select tags for deployment on a web page. In some embodiments, a user may refer to a website, website host, website administrator, website consultant, or the like, or an agent thereof. Tags may be in one of a plurality of states, such as, for example, a NORMAL state, a FLAGGED state, a SUSPENSION A state, or a SUSPENSION B state. In at least one embodiment, tags in the NORMAL state or the FLAGGED state may be enabled to be deployed (i.e., available for deployment), and tags in the SUSPENSION_A state or the SUSPENSION_B state may be blocked from being deployed (i.e., suspended from deployment).
Tag latency may be asynchronously monitored independent of web page requests. In some embodiments, a frequency to monitor the tags may be based on a tag's state. A tag's state may change based on the asynchronous monitoring of the tag's latency. Briefly, in some embodiments, if a latent event occurs (i.e., the tag latency exceeds a maximum time latency threshold), then the tag's state may change from NORMAL to FLAGGED, from FLAGGED to SUSPENSION A, or from SUSPENSION B to SUSPENSION A. In other embodiments, if a non-latent event occurs (i.e., the tag latency does not exceed the maximum time latency threshold), then the tag's state may change from SUSPENSION B to FLAGGED or from FLAGGED to NORMAL. In at least one embodiment, consecutive latent events or consecutive non-latent events may be utilized to change a tag's state. By employing a plurality of different states and changing a tag's states based on latent/non-latent events (and/or consecutive latent/non-latent events), a tag may not be prematurely blocked from deployment due to an abrupt increase in tag latency or prematurely enabled for deployment after being blocked due to an abrupt decrease in tag latency.
Illustrative Operating Environment
FIG. 1 shows components of one embodiment of an environment in which embodiments of the invention may be practiced. Not all of the components may be required to practice the invention, and variations in the arrangement and type of the components may be made without departing from the spirit or scope of the invention. As shown, system 100 of FIG. 1 includes local area networks (LANs)/wide area networks (WANs)-(network) 110, wireless network 108, client devices 102-105, Tag Monitoring Server Device (TMSD) 112, Tag Control Server Device (TCSD) 114, and Tag Deployment Server Device (TDSD) 116.
At least one embodiment of client devices 102-105 is described in more detail below in conjunction with FIG. 2. In one embodiment, at least some of client devices 102-105 may operate over a wired and/or wireless network, such as networks 110 and/or 108. Generally, client devices 102-105 may include virtually any computing device capable of communicating over a network to send and receive information, perform various online activities, offline actions, or the like. In one embodiment, one or more of client devices 102-105 may be configured to operate within a business or other entity to perform a variety of services for the business or other entity. For example, client devices 102-105 may be configured to operate as a web server, an accounting server, a production server, an inventory server, or the like. However, client devices 102-105 are not constrained to these services and may also be employed, for example, as an end-user computing node, in other embodiments. It should be recognized that more or less client devices may be included within a system such as described herein, and embodiments are therefore not constrained by the number or type of client devices employed.
Devices that may operate as client device 102 may include devices that typically connect using a wired or wireless communications medium such as personal computers, multiprocessor systems, microprocessor-based or programmable electronic devices, network PCs, or the like. In some embodiments, client devices 102-105 may include virtually any portable personal computing device capable of connecting to another computing device and receiving information such as, laptop computer 103, smart mobile telephone 104, and tablet computers 105, and the like. However, portable computing devices are not so limited and may also include other portable devices such as cellular telephones, display pagers, radio frequency (RF) devices, infrared (IR) devices, Personal Digital Assistants (PDAs), handheld computers, wearable computers, integrated devices combining one or more of the preceding devices, and the like. As such, client devices 102-105 typically range widely in terms of capabilities and features. Moreover, client devices 102-105 may access various computing applications, including a browser, or other web-based application.
A web-enabled client device may include a browser application that is configured to receive and to send web pages, web-based messages, and the like. The browser application may be configured to receive and display graphics, text, multimedia, and the like, employing virtually any web-based language, including a wireless application protocol messages (WAP), and the like. In one embodiment, the browser application is enabled to employ Handheld Device Markup Language (HDML), Wireless Markup Language (WML), WMLScript, JavaScript, Standard Generalized Markup Language (SGML), HyperText Markup Language (HTML), extensible Markup Language (XML), and the like, to display and send a message. In one embodiment, a user of the client device may employ the browser application to perform various activities over a network (online). However, another application may also be used to perform various online activities.
Client devices 102-105 also may include at least one other client application that is configured to receive and/or send content between another computing device. The client application may include a capability to send and/or receive content, or the like. The client application may further provide information that identifies itself, including a type, capability, name, and the like. In one embodiment, client devices 102-105 may uniquely identify themselves through any of a variety of mechanisms, including an Internet Protocol (IP) address, a phone number, Mobile Identification Number (MIN), an electronic serial number (ESN), or other device identifier. Such information may be provided in a network packet, or the like, sent between other client devices, TMSD 112, TCSD 114, TDSD 116, or other computing devices.
Client devices 102-105 may further be configured to include a client application that enables an end-user to log into an end-user account that may be managed by another computing device, such as TMSD 112, TCSD 114, TDSD 116, or the like. Such end-user account, in one non-limiting example, may be configured to enable the end-user to manage one or more online activities, including in one non-limiting example, search activities, social networking activities, browse various websites, communicate with other users, or the like. However, participation in such online activities may also be performed without logging into the end-user account.
Wireless network 108 is configured to couple client devices 103-105 and its components with network 110. Wireless network 108 may include any of a variety of wireless sub-networks that may further overlay stand-alone ad-hoc networks, and the like, to provide an infrastructure-oriented connection for client devices 103-105. Such sub-networks may include mesh networks, Wireless LAN (WLAN) networks, cellular networks, and the like. In one embodiment, the system may include more than one wireless network.
Wireless network 108 may further include an autonomous system of terminals, gateways, routers, and the like connected by wireless radio links, and the like. These connectors may be configured to move freely and randomly and organize themselves arbitrarily, such that the topology of wireless network 108 may change rapidly.
Wireless network 108 may further employ a plurality of access technologies including 2nd (2G), 3rd (3G), 4th (4G) 5th (5G) generation radio access for cellular systems, WLAN, Wireless Router (WR) mesh, and the like. Access technologies such as 2G, 3G, 4G, 5G, and future access networks may enable wide area coverage for mobile devices, such as client devices 103-105 with various degrees of mobility. In one non-limiting example, wireless network 108 may enable a radio connection through a radio network access such as Global System for Mobil communication (GSM), General Packet Radio Services (GPRS), Enhanced Data GSM Environment (EDGE), code division multiple access (CDMA), time division multiple access (TDMA), Wideband Code Division Multiple Access (WCDMA), High Speed Downlink Packet Access (HSDPA), Long Term Evolution (LTE), and the like. In essence, wireless network 108 may include virtually any wireless communication mechanism by which information may travel between client devices 103-105 and another computing device, network, and the like.
Network 110 is configured to couple network devices with other computing devices, including, TMSD 112, TCSD 114, TDSD 116, client device 102, and client devices 103-105 through wireless network 108. Network 110 is enabled to employ any form of computer readable media for communicating information from one electronic device to another. Also, network 110 can include the Internet in addition to local area networks (LANs), wide area networks (WANs), direct connections, such as through a universal serial bus (USB) port, other forms of computer-readable media, or any combination thereof. On an interconnected set of LANs, including those based on differing architectures and protocols, a router acts as a link between LANs, enabling messages to be sent from one to another. In addition, communication links within LANs typically include twisted wire pair or coaxial cable, while communication links between networks may utilize analog telephone lines, full or fractional dedicated digital lines including T1, T2, T3, and T4, and/or other carrier mechanisms including, for example, E-carriers, Integrated Services Digital Networks (ISDNs), Digital Subscriber Lines (DSLs), wireless links including satellite links, or other communications links known to those skilled in the art. Moreover, communication links may further employ any of a variety of digital signaling technologies, including without limit, for example, DS-0, DS-1, DS-2, DS-3, DS-4, OC-3, OC-12, OC-48, or the like. Furthermore, remote computers and other related electronic devices could be remotely connected to either LANs or WANs via a modem and temporary telephone link. In one embodiment, network 110 may be configured to transport information of an Internet Protocol (IP). In essence, network 110 includes any communication method by which information may travel between computing devices.
Additionally, communication media typically embodies computer readable instructions, data structures, program modules, or other transport mechanism and includes any information delivery media. By way of example, communication media includes wired media such as twisted pair, coaxial cable, fiber optics, wave guides, and other wired media and wireless media such as acoustic, RF, infrared, and other wireless media.
One embodiment of TMSD 112 is described in more detail below in conjunction with FIG. 3. Briefly, however, TMSD 112 includes virtually any network device capable of monitoring tag latency. In at least one embodiment, TMSD 112 may asynchronously monitor the performance and latency of tags. Asynchronous monitoring may be performed independent of a request to load a web page (e.g., from a visitor to a website). TMSD 112 may emulate a browser to request a tag and determine tag latency. In at least one embodiment, TMSD 112 may determine the tag latency by calculating a time it takes the requested tag to load in the emulated browser. In some embodiments, TMSD 112 may communicate with TCSD 114 to determine which tags to monitor and/or to provide the determined tag latency. Devices that may be arranged to operate as TMSD 112 include various network devices, including, but not limited to personal computers, desktop computers, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, server devices, network appliances, and the like.
Although FIG. 1 illustrates TMSD 112 as a single computing device, the invention is not so limited. For example, one or more functions of the TMSD 112 may be distributed across one or more distinct network devices. Moreover, TMSD 112 is not limited to a particular configuration. Thus, in one embodiment, TMSD 112 may contain a plurality of network devices to monitor tag latency. In another embodiment, TMSD 112 may contain a plurality of network devices that operate using a master/slave approach, where one of the plurality of network devices of TMSD 112 operates to manage and/or otherwise coordinate operations of the other network devices. In other embodiments, the TMSD 112 may operate as a plurality of network devices within a cluster architecture, a peer-to-peer architecture, and/or even within a cloud architecture. Thus, the invention is not to be construed as being limited to a single environment, and other configurations, and architectures are also envisaged. In at least one embodiment, each of a plurality of TMSD 112 may be geographically distributed. In another embodiment, TMSD 112 may include a different computing device for monitoring tags in each of a plurality of different tag states.
In at least one embodiment, the system may be scaled up or down by adding or removing network devices, such as TMSD 112, to or from the system. In some embodiments, adding additional TMSDs to the system can enable higher throughput of tag monitoring. In at least one embodiment, each TMSD may be designed to enable system scaling such that scaling may be implemented without adding additional scaling features to each TMSD at the time of scaling.
At least one embodiment of TCSD 114 is described in more detail below in conjunction with FIG. 3. Briefly, however, TCSD 114 may include virtually any network device capable of controlling a state of each of a plurality of tags and enabling available tags to be deployed based on the tag's state. In some embodiment, TCSD 114 may communicate with TMSD 112 to determine which tags to monitor and/or may receive tag latency information. In some embodiments, TCSD 114 may provide TDSD 116 with a list of tags available for deployment. In at least one embodiment, TCSD 114 may communicate with a database (not shown), which may maintain tables for each tag state, which may include a list of each tag in that state. Devices that may operate as TCSD 114 include various network devices, including, but not limited to personal computers, desktop computers, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, server devices, network appliances, and the like.
Although FIG. 1 illustrates TCSD 114 as a single computing device, the invention is not so limited. For example, one or more functions of the TCSD 114 may be distributed across one or more distinct network devices. Moreover, TCSD 114 is not limited to a particular configuration. Thus, in one embodiment, TCSD 114 may contain a plurality of network devices to control tag monitoring and/or deployment availability. Similarly, in another embodiment, TCSD 114 may contain a plurality of network devices that operate using a master/slave approach, where one of the plurality of network devices of TCSD 114 operates to manage and/or otherwise coordinate operations of the other network devices. In other embodiments, the TCSD 114 may operate as a plurality of network devices within a cluster architecture, a peer-to-peer architecture, and/or even within a cloud architecture. Thus, the invention is not to be construed as being limited to a single environment, and other configurations, and architectures are also envisaged.
At least one embodiment of TDSD 116 is described in more detail below in conjunction with FIG. 3. Briefly, however, TDSD 116 may include virtually any network device capable of deploying a tag. In some embodiments, TDSD 116 may be optimized to provide tags to websites upon a web request (e.g., a request from a visitor to the website to view a web page). In at least one embodiment, TDSD 116 may communicate with TCSD 114 to receive a list of tags available for deployment. In some embodiments, TDSD 116 may collect data about a web page and may record information about deployed tags. Devices that may operate as TDSD 116 include various network devices, including, but not limited to personal computers, desktop computers, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, server devices, network appliances, and the like.
Although FIG. 1 illustrates TDSD 116 as a single computing device, the invention is not so limited. For example, one or more functions of the TDSD 116 may be distributed across one or more distinct network devices. Moreover, TDSD 116 is not limited to a particular configuration. Thus, in one embodiment, TDSD 116 may contain a plurality of network devices to deploy tags to web pages. Similarly, in another embodiment, TDSD 116 may contain a plurality of network devices that operate using a master/slave approach, where one of the plurality of network devices of TDSD 116 operates to manage and/or otherwise coordinate operations of the other network devices. In other embodiments, the TDSD 116 may operate as a plurality of network devices within a cluster architecture, a peer-to-peer architecture, and/or even within a cloud architecture. Thus, the invention is not to be construed as being limited to a single environment, and other configurations, and architectures are also envisaged.
Illustrative Client Device
FIG. 2 shows one embodiment of client device 200 that may be included in a system implementing embodiments of the invention. Client device 200 may include many more or less components than those shown in FIG. 2. However, the components shown are sufficient to disclose an illustrative embodiment for practicing the present invention. Client device 200 may represent, for example, one embodiment of at least one of client devices 102-105 of FIG. 1.
As shown in the figure, client device 200 includes a processor 202 in communication with a mass memory 226 via a bus 234. In some embodiments, processor 202 may include one or more central processing units (CPU). Client device 200 also includes a power supply 228, one or more network interfaces 236, an audio interface 238, a display 240, a keypad 242, an illuminator 244, a video interface 246, an input/output interface 248, a haptic interface 250, and a global positioning system (GPS) receiver 232.
Power supply 228 provides power to client device 200. A rechargeable or non-rechargeable battery may be used to provide power. The power may also be provided by an external power source, such as an alternating current (AC) adapter or a powered docking cradle that supplements and/or recharges a battery.
Client device 200 may optionally communicate with a base station (not shown), or directly with another computing device. Network interface 236 includes circuitry for coupling client device 200 to one or more networks, and is constructed for use with one or more communication protocols and technologies including, but not limited to, GSM, CDMA, TDMA, GPRS, EDGE, WCDMA, HSDPA, LTE, user datagram protocol (UDP), transmission control protocol/Internet protocol (TCP/IP), short message service (SMS), WAP, ultra wide band (UWB), IEEE 802.16 Worldwide Interoperability for Microwave Access (WiMax), session initiated protocol/real-time transport protocol (SIP/RTP), or any of a variety of other wireless communication protocols. Network interface 236 is sometimes known as a transceiver, transceiving device, or network interface card (NIC).
Audio interface 238 is arranged to produce and receive audio signals such as the sound of a human voice. For example, audio interface 238 may be coupled to a speaker and microphone (not shown) to enable telecommunication with others and/or generate an audio acknowledgement for some action.
Display 240 may be a liquid crystal display (LCD), gas plasma, light emitting diode (LED), organic LED, or any other type of display used with a computing device. Display 240 may also include a touch sensitive screen arranged to receive input from an object such as a stylus or a digit from a human hand.
Keypad 242 may comprise any input device arranged to receive input from a user. For example, keypad 242 may include a push button numeric dial, or a keyboard. Keypad 242 may also include command buttons that are associated with selecting and sending images.
Illuminator 244 may provide a status indication and/or provide light. Illuminator 244 may remain active for specific periods of time or in response to events. For example, when illuminator 244 is active, it may backlight the buttons on keypad 242 and stay on while the client device is powered. Also, illuminator 244 may backlight these buttons in various patterns when particular actions are performed, such as dialing another client device. Illuminator 244 may also cause light sources positioned within a transparent or translucent case of the client device to illuminate in response to actions.
Video interface 246 is arranged to capture video images, such as a still photo, a video segment, an infrared video, or the like. For example, video interface 246 may be coupled to a digital video camera, a web-camera, or the like. Video interface 246 may comprise a lens, an image sensor, and other electronics. Image sensors may include a complementary metal-oxide-semiconductor (CMOS) integrated circuit, charge-coupled device (CCD), or any other integrated circuit for sensing light.
Client device 200 also comprises input/output interface 248 for communicating with external devices, such as a headset, or other input or output devices not shown in FIG. 2. Input/output interface 248 can utilize one or more communication technologies, such as USB, infrared, BluetoothTM, or the like.
Haptic interface 250 is arranged to provide tactile feedback to a user of the client device. For example, the haptic interface 250 may be employed to vibrate client device 200 in a particular way when another user of a computing device is calling. In some embodiments, haptic interface 250 may be optional.
Client device 200 may also include GPS transceiver 232 to determine the physical coordinates of client device 200 on the surface of the Earth. GPS transceiver 232, in some embodiments, may be optional. GPS transceiver 232 typically outputs a location as latitude and longitude values. However, GPS transceiver 232 can also employ other geo-positioning mechanisms, including, but not limited to, triangulation, assisted GPS (AGPS), Enhanced Observed Time Difference (E-OTD), Cell Identifier (CI), Service Area Identifier (SAI), Enhanced Timing Advance (ETA), Base Station Subsystem (BSS), or the like, to further determine the physical location of client device 200 on the surface of the Earth. It is understood that under different conditions, GPS transceiver 232 can determine a physical location within millimeters for client device 200; and in other cases, the determined physical location may be less precise, such as within a meter or significantly greater distances. In one embodiment, however, mobile device 200 may through other components, provide other information that may be employed to determine a physical location of the device, including for example, a Media Access Control (MAC) address, IP address, or the like.
Mass memory 226 includes a Random Access Memory (RAM) 204, a Read-only Memory (ROM) 222, and other storage means. Mass memory 226 illustrates an example of computer readable storage media (devices) for storage of information such as computer readable instructions, data structures, program modules or other data. Mass memory 226 stores a basic input/output system (BIOS) 224 for controlling low-level operation of client device 200. The mass memory also stores an operating system 206 for controlling the operation of client device 200. It will be appreciated that this component may include a general-purpose operating system such as a version of UNIX, or LINUXTM, or a specialized client communication operating system such as Microsoft Corporation's Windows MobileTM, Apple Corporation's iOSTM, Google Corporation's AndroidTM or the Symbian® operating system. The operating system may include, or interface with a Java virtual machine module that enables control of hardware components and/or operating system operations via Java application programs.
Mass memory 226 further includes one or more data storage 208, which can be utilized by client device 200 to store, among other things, applications 214 and/or other data. For example, data storage 208 may also be employed to store information that describes various capabilities of client device 200. The information may then be provided to another device based on any of a variety of events, including being sent as part of a header during a communication, sent upon request, or the like. Data storage 208 may also be employed to store social networking information including address books, buddy lists, aliases, user profile information, or the like. Further, data storage 208 may also store message, we page content, or any of a variety of user generated content. At least a portion of the information may also be stored on another component of network device 200, including, but not limited to processor readable storage media 230, a disk drive or other computer readable storage devices (not shown) within client device 200.
Processor readable storage media 230 may include volatile, nonvolatile, removable, and non-removable media implemented in any method or technology for storage of information, such as computer- or processor-readable instructions, data structures, program modules, or other data. Examples of computer readable storage media include RAM, ROM, Electrically Erasable Programmable Read-only Memory (EEPROM), flash memory or other memory technology, Compact Disc Read-only Memory (CD-ROM), digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other physical medium which can be used to store the desired information and which can be accessed by a computing device. Processor readable storage media 230 may also be referred to herein as computer readable storage media and/or computer readable storage device.
Applications 214 may include computer executable instructions which, when executed by client device 200, transmit, receive, and/or otherwise process network data. Network data may include, but is not limited to, messages (e.g. SMS, Multimedia Message Service (MMS), instant message (IM), email, and/or other messages), audio, video, and enable telecommunication with another user of another client device. Applications 214 may include, for example, browser 218, and other applications 220. Other applications 220 may include, but are not limited to, calendars, search programs, email clients, IM applications, SMS applications, voice over Internet Protocol (VOIP) applications, contact managers, task managers, transcoders, database programs, word processing programs, security applications, spreadsheet programs, games, search programs, and so forth.
Browser 218 may include virtually any application configured to receive and display graphics, text, multimedia, messages, and the like, employing virtually any web based language. In one embodiment, the browser application is enabled to employ HDML, WML, WMLScript, JavaScript, SGML, HTML, XML, and the like, to display and send a message. However, any of a variety of other web-based programming languages may be employed. In one embodiment, browser 218 may enable a user of client device 200 to communicate with another network device, such as TMSD 112, TCSD 114, and/or TDSD 116 of FIG. 1.
Illustrative Network Device
FIG. 3 shows one embodiment of a network device 300, according to one embodiment of the invention. Network device 300 may include many more or less components than those shown. The components shown, however, are sufficient to disclose an illustrative embodiment for practicing the invention. Network device 300 may be configured to operate as a server, client, peer, a host, or any other device. Network device 300 may represent, for example TMSD 112, TCSD 114, TDSD 116 of FIG. 1, and/or other network devices.
Network device 300 includes processor 302, processor readable storage media 328, network interface unit 330, an input/output interface 332, hard disk drive 334, video display adapter 336, and memory 326, all in communication with each other via bus 338. In some embodiments, processor 302 may include one or more central processing units.
As illustrated in FIG. 3, network device 300 also can communicate with the Internet, or some other communications network, via network interface unit 330, which is constructed for use with various communication protocols including the TCP/IP protocol. Network interface unit 330 is sometimes known as a transceiver, transceiving device, or network interface card (NIC).
Network device 300 also comprises input/output interface 332 for communicating with external devices, such as a keyboard, or other input or output devices not shown in FIG. 3. Input/output interface 332 can utilize one or more communication technologies, such as USB, infrared, BluetoothTM, or the like.
Memory 326 generally includes RAM 304, ROM 322 and one or more permanent mass storage devices, such as hard disk drive 334, tape drive, optical drive, and/or floppy disk drive. Memory 326 stores operating system 306 for controlling the operation of network device 300. Any general-purpose operating system may be employed. Basic input/output system (BIOS) 324 is also provided for controlling the low-level operation of network device 300.
Although illustrated separately, memory 326 may include processor readable storage media 328. Processor readable storage media 328 may be referred to and/or include computer readable media, computer readable storage media, and/or processor readable storage device. Processor readable storage media 328 may include volatile, nonvolatile, removable, and non-removable media implemented in any method or technology for storage of information, such as computer readable instructions, data structures, program modules, or other data. Examples of processor readable storage media include RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other media which can be used to store the desired information and which can be accessed by a computing device.
Memory 326 further includes one or more data storage 308, which can be utilized by network device 300 to store, among other things, applications 314 and/or other data. For example, data storage 308 may also be employed to store information that describes various capabilities of network device 300. The information may then be provided to another device based on any of a variety of events, including being sent as part of a header during a communication, sent upon request, or the like. Data storage 308 may also be employed to store messages, web page content, or the like. At least a portion of the information may also be stored on another component of network device 300, including, but not limited to processor readable storage media 328, hard disk drive 334, or other computer readable storage medias (not shown) within client device 300
Data storage 308 may include a database, text, spreadsheet, folder, file, or the like, that may be configured to maintain and store user account identifiers, user profiles, email addresses, IM addresses, and/or other network addresses; or the like. Data storage 308 may further include program code, data, algorithms, and the like, for use by a processor, such as processor 302 to execute and perform actions. In at least one embodiment data storage 308 may include at least one state table to indicate which tags are in a particular state. In one embodiment, at least some of data store 308 might also be stored on another component of network device 300, including, but not limited to processor-readable storage media 328, hard disk drive 334, or the like.
Applications 314 may include computer executable instructions, which may be loaded into mass memory and run on operating system 306. Examples of application programs may include transcoders, schedulers, calendars, database programs, word processing programs, Hypertext Transfer Protocol (HTTP) programs, customizable user interface programs, IPSec applications, encryption programs, security programs, SMS message servers, IM message servers, email servers, account managers, and so forth. Applications 314 may also include website server 318, Tag Monitoring Application (TMA) 319, Tag Deployment Application (TDA) 320, and Tag Control Application (TCA) 321.
Website server 318 may represents any of a variety of information and services that are configured to provide content, including messages, over a network to another computing device. Thus, website server 318 can include, for example, a web server, a File Transfer Protocol (FTP) server, a database server, a content server, or the like. Website server 318 may provide the content including messages over the network using any of a variety of formats including, but not limited to WAP, HDML, WML, SGML, HTML, XML, Compact HTML (cHTML), Extensible HTML (xHTML), or the like.
TMA 319 may be configured to asynchronously monitor tag latency. In at least one embodiment, TMA 319 may asynchronously monitor tag latency independent of a request to load a web page (e.g., from a visitor to a website). TMA 319 may emulate a browser to request a tag and determine tag latency. In at least one embodiment, TMA 319 may determine the tag latency by calculating a time it takes the request tag to load in the emulated browser. In some embodiments, TMA 319 may be employed by TMSD 112 of FIG. 1. In any event, TMA 319 may employ processes, or parts of processes, similar to those described in conjunction with FIGS. 4-7, and 9A-9B to perform at least some of its actions.
TDA 320 may be configured to deploy a tag. In some embodiments, TDA 320 may provide tags to websites upon request (e.g., a request from a visitor to the website to view a web page). In at least one embodiment, TDA 320 may collect data about a web page and may record information about deployed tags. In some embodiments, TDA 320 may be employed by TDSD 116 of FIG. 1. In any event, TDA 319 may employ processes, or parts of processes, similar to those described in conjunction with FIGS. 4-7, and 9A-9B to perform at least some of its actions.
TCA 321 may be configured to control a state of each of a plurality of tags. In some embodiments, TCA 321 may be configured to notify and/or provide TMA 319 with each tag that may be ready to be monitored. In some embodiments, TCA 321 may record a last time a tag was checked (i.e., when a tag latency is determined for a tag), which may be utilized to determine a next time to check the tag. In at least one embodiment, TCA 321 may record tag measurements (e.g., tag latency) that are returned from TMA 319. These measurements may be utilized by TCA 321 to determine if a state of a tag should be changed or may be utilized for historical reporting purposes.
In at least one embodiment, TCA 321 may change a state of a tag. In some embodiments, TCA 321 may modify a state table to add or remove a tag from a given state. In some embodiments, TCA 321 may be configured to enable available tags for deployment or block tags from deployment (i.e., disable tags) based on a tag's state. In at least one embodiment, TCA 321 may be configured to provide and/or notify TDA 320 of tags available for deployment. In some embodiments, TCA 321 may be employed by TCSD 114 of FIG. 1. In any event, TCA 321 may employ processes, or parts of processes, similar to those described in conjunction with FIGS. 4-7, and 9A-9B to perform at least some of its actions.
General Operation
The operation of certain aspects of the invention will now be described with respect to FIGS. 4-7. FIG. 4 illustrates a logical flow diagram generally showing one embodiment of an overview process for changing a tag state based on asynchronous monitoring of the tag's latency and enabling the tag for deployment based on a state of the tag. In some embodiments, process 400 of FIG. 4 may be implemented by and/or executed on a single network device, such as network device 300 of FIG. 3. In other embodiments, process 400 or portions of process 400 of FIG. 4 may be implemented by and/or executed on a plurality of network devices, such as network device 300 of FIG. 3. In at least one of various embodiments, process 400 may be performed for each of a plurality of tags.
Process 400 begins, after a start block, at block 402, where a tag may be determined for monitoring. In some embodiments, each of a plurality of tags may be monitored, wherein each tag may be associated with at least one web page. In other embodiments, a portion of the plurality of tags may be monitored and another portion of the plurality of tags may not be monitored. In at least one embodiment, the tags to be monitored may be predetermined, determined, modified by a user, or the like.
In some embodiments, a tag may be in one of a plurality of different states. Each state may enable a tag to be deployed or may block a tag from being deployed. A tag's state may change from one state to another state based on the monitoring, a time a tag is in a state, or the like, or a combination thereof. In some embodiments, different triggers (i.e., a number of consecutive latent events) may be employed for moving a tag from one state to another state. Embodiments of processes for changing a tag's state are described in more detail below in conjunction with FIGS. 7 and 9A-9B. In at least one embodiment, a tag may be in one of the following states: NORMAL, FLAGGED, SUSPENSION A, or SUSPENSION B. One embodiment of a graphic illustration of these different states is described in more detail below in conjunction with FIG. 8.
However, embodiments are not so limited and other numbers of states, types of states, algorithms/metrics for state changes, or the like, may be employed. For example, in at least one embodiment, a tag may be in one of the following states: NORMAL, FLAGGED, PRE-SUSPENDED, SUSPENDED, or POST-SUSPENDED. One embodiment of a graphic illustration of these different states is described in more detail below in conjunction with FIG. 10. In another embodiment, historical records of measurements (e.g., tag latency) may be utilized to modify the number of states and/or types of states, the metrics utilized to change a tag's state, or the like. For example, historical records may indicate that tags may become stuck in a specific state for prolonged periods of time. In one such example, an additional state may be added, which may be utilized to monitor tags more frequently. In another example, if historical records may indicate that a tag routinely results in latent events at a given time (e.g., because of routine server maintenance), then the tag may be preemptively moved to a different state at the given time.
In any event, process 400 continues at block 404, where tag latency may be asynchronously monitored. In some embodiments, monitoring may be asynchronous if it is independent of a request for a web page from a visitor to the web page. In at least one embodiment, the monitoring may be based on at least a state of the tag to be monitored. In some embodiments, a tag's state may determine a rate and/or frequency at which to monitor the tag. In some embodiments, the rate at which to monitor tag may be configurable and/or modifiable for each individual state. In one embodiment, each state may correspond to a different frequency for asynchronously monitoring a tag. For example, a tag in a NORMAL state may monitored every 15 minutes, a tag in a FLAGGED state may be monitored every five minutes, a tag in a SUSPENSION B state may be monitored every minute, while a tag in a SUSPENSION_A state may be idle and not monitored for a predetermined amount of time. However, embodiments are not so limited and other frequencies for periodically monitoring tag latency may be employed.
In some other embodiments, a latency to monitor the tag may be determined. In at least one embodiment, the latency may be determined by measuring a time from a tag request to receipt of a server response. However, embodiments are not so limited and other methods for determining the tag latency may be employed, which is described in more detail above.
Process 400 next proceeds to decision block 406, where a determination may be made whether the tag latency resulted in a latent event. In at least one embodiment, the tag latency may be compared to a maximum time latency threshold. If the tag latency is greater than the maximum time latency threshold, then the result of the tag monitoring may indicate a latent event occurred. In at least one embodiment, the maximum time latency threshold may be configured and/or modifiable for each user and/or each state. Accordingly, the maximum time latency threshold may be the same and/or different for each user and/or state. If the tag latency is less than the maximum time latency threshold, then the result of the tag monitoring may indicate a non-latent event occurred. If a latent event occurred, then processing may flow to block 408; otherwise, a non-latent event may have occurred and processing may flow to block 410.
At block 408, a tag state may be changed based on the latent event, which is described in more detail below in conjunction with FIG. 5. Briefly, however, if a determination of the latency (e.g., consecutive latent events) and the state of the tag indicates a modification to the state, then the state of the tag may be modified to another state. In some embodiment, a tag may change states based on a current state of the tag and if a number of latent events exceeds a latent event threshold. For example, in some embodiments, a tag may change from a NORMAL state to a FLAGGED state if a threshold number of latent events is exceeded. In other embodiments, a tag may change from a FLAGGED state to a SUSPENSION A state, if a threshold number of latent events is exceeded. In yet other embodiments, a tag may change from a SUSPENSION B state to a SUSPENSION A state if a threshold number of latent events is exceeded. In some embodiments, the latent event threshold may be any suitable number of consecutive latent events, such as, for example, 1-3 consecutive latent events. In other embodiments, the latent event threshold may be any suitable number of latent events that occur within a given period of time (e.g., 3 latent events in five minutes). However, embodiments are not so limited, and the latent event threshold may be based on other metrics/algorithms to determine if a tag is moved from a given state and which state the tag is moved to.
For example, a tag may change from one state to another state based on: a severity of a latent event (e.g., a tag latency value above a severity threshold value), a number of consecutive latent events above the severity threshold, a number of latent events above the severity threshold within a predetermined time period, a time duration a tag is in a given state, or the like, or any combination thereof. In some embodiments, the latent event threshold employed at each state may be individually configurable and/or modifiable. In at least one embodiment, each of these latent event thresholds may be separately configured for each user. Processing then proceeds to decision block 412.
If, at decision block 406, it is determined that a non-latent event occurred, then processing may flow from decision block 406 to block 410. At block 410, a state of the tag may be changed based on the non-latent event, which is described in more detail below in conjunction with FIG. 6. Briefly, however, if a determination of the latency (e.g., consecutive non-latent events) and the state of the tag indicates a modification to the state, then the state of the tag may be modified to another state. In some embodiment, a tag may change states based on a current state of the tag and if a number of latent events exceeds a non-latent event threshold.
In some embodiments, a tag may change from a FLAGGED state to a NORMAL state, if a threshold number of non-latent events is exceeded. In other embodiments, a tag may change from a SUSPENSION B state to a FLAGGED state if a threshold number of non-latent events is exceeded. In some embodiments, the non-latent event threshold may be any suitable number of consecutive non-latent events, such as, for example, 1-3 non-latent consecutive events. In other embodiments, the non-latent event threshold may be any suitable number of non-latent events that occur within a given period of time (e.g., 3 non-latent events in one minute). However, embodiments are not so limited, and the non-latent event threshold may be based on other metrics/algorithms to determine if a tag is moved from a given state and which state the tag is moved to.
For example, a tag may change from one state to another state based on: a mildness of one or more non-latent events (e.g., a tag latency value below a mildness threshold value), a number of consecutive non-latent events below the mildness threshold, a number of non-latent events below the mildness threshold within a predetermined time period, a time duration a tag is in a given state, or the like, or any combination thereof. In some embodiments, the non-latent event threshold employed at each state may be individually configurable and/or modifiable. In at least one embodiment, each of these non-latent event thresholds may be separately configured for each user.
Process 400 next proceeds to decision block 412, where a determination may be made whether the tag is blocked from being deployed based on a current state of the tag. In some embodiments, a tag in a NORMAL state and/or a FLAGGED state may not be blocked and may be allowed to be deployed. In other embodiments, a tag in a SUSPENSION_A state and/or a SUSPENSION_B state may be blocked and may not be allowed to be deployed. If the tag is blocked from being deployed, then processing may loop to block 404 to continue to asynchronously monitor tag latency; otherwise, processing may flow to block 414.
At block 414, the tag may be enabled to be deployed. In some embodiments, enabling a tag to be deployed may include notifying a web page that a tag can be requested and loaded in the web page if a web page request is provided. In other embodiments, enabling a tag to be deployed may include notifying a tag deployment device, such as TDSD 116 of FIG. 1, to request and load the tag if a request for a web page is provided. In at least one embodiment, tags enabled for deployment may be included in a table or list of tags available for deployment. In some embodiments, if a determination of a current state of the tag affirmatively indicates deployment (as determined by block 412) and a web page is requested, the tag may be deployed with the associated web page.
After block 414, process 400 may loop to block 404 to continue to asynchronously monitor tag latency.
FIG. 5 illustrates a logical flow diagram generally showing one embodiment of a process for changing a tag state based on a latent event of the tag and a current state of the tag. In some embodiments, process 500 of FIG. 5 may be implemented by and/or executed on a single network device, such as network device 300 of FIG. 3. In other embodiments, process 500 or portions of process 500 of FIG. 5 may be implemented by and/or executed on a plurality of network devices, such as network device 300 of FIG. 3.
Process 500 begins, after a start block, at decision block 502, where a determination may be made whether the tag is in a NORMAL state. In at least one embodiment, each state (i.e., NORMAL state, FLAGGED state, SUSPENSION_A state, and/or SUSPENSION B state) may correspond to a table that identifies the tags in that particular state. For example, a normal tag table may identify tags in the NORMAL state; a flagged tag table may identify tags in the FLAGGED state; a SUSPENSION_A tag table may identify tags in the SUSPENSION_A state; and a SUSPENSION_B tag table may identify tags in the SUSPENSION B state. In some embodiments, a tag may be determined to be in the NORMAL state if the tag is included in the normal tag table. If the tag is in the NORMAL state, then processing may flow to decision block 504; otherwise, processing may flow to decision block 510.
At decision block 504, a determination may be made whether a latent event threshold is exceeded. In some embodiments, the latent event threshold may be a total number of consecutive latent events. In one non-limiting, non-exhaustive example, the latent event threshold for the NORMAL state may be one latent event. In at least one such embodiment, determining if the latent event threshold is exceeded may include comparing a number of consecutive latent events to the latent event threshold. In other embodiments, the latent event threshold may be a total number of latent events that occurred within a given time period. However, embodiments are not so limited and other latent event thresholds may be employed. If the latent event threshold is exceeded, then processing may flow to block 506; otherwise, processing may flow to block 508.
At block 506, the tag may be moved to the FLAGGED state. In at least one embodiment, moving the tag to the FLAGGED state may include removing the tag from the NORMAL tag table and adding the tag to the FLAGGED tag table. However, embodiments are not so limited and other methods of identifying and changing the tag state may be employed. In some embodiments, a tag in the FLAGGED state may not be blocked and may be enabled to be deployed. In at least one embodiment, an email, text message, or other notification may be sent to a user to indicate that the tag was moved to the FLAGGED state. In some other embodiments, if the tag returns an error (e.g., HTTP 4xx|5xx responses) when the tag latency of the tag is monitored, then the tag may be moved to the FLAGGED state. After block 506, process 500 may return to a calling process to perform other actions.
If, at decision block 504, it is determined that the latent event threshold is not exceeded, then processing may flow from decision block 504 to block 508. At block 508, the tag may remain in the NORMAL state. In at least one embodiment, a tag in the NORMAL state may not be blocked and may be enabled to be deployed. After block 506, process 500 may return to a calling process to perform other actions.
If, at decision block 502, it is determined that the tag is not in the NORMAL state, then processing may flow from decision block 502 to decision block 510. At decision block 510, a determination may be made whether the tag is in the FLAGGED state. In some embodiments, a tag may be determined to be in the FLAGGED state if the tag is included in the flagged tag table. If the tag is in the FLAGGED state, then processing may flow to decision block 512; otherwise, processing may flow to decision block 516.
At decision block 512, a determination may be made whether a latent event threshold is exceeded. In at least one embodiment, decision block 512 may employ embodiments of decision block 504 to determine if the latent event threshold is exceeded. In some embodiments, the latent event threshold for the FLAGGED state may be the same or different than the latent event threshold for the NORMAL state. In one non-limiting, non-exhaustive example, the threshold number of latent events for the FLAGGED state may be three consecutive latent events. However, embodiments are not so limited and other latent event thresholds may be employed. If the latent event threshold is exceeded, then processing may flow to block 524; otherwise, processing may flow to block 514.
At block 514, the tag may remain in the flagged state. In at least one embodiment, a tag in the FLAGGED state may not be blocked and may be enabled to be deployed. After block 514, process 500 may return to a calling process to perform other actions.
If, at decision block 510, it is determined that the tag is not in the FLAGGED state, then processing may flow from decision block 510 to decision block 516. At decision block 516, a determination may be made whether the tag is in the SUSPENSION B state. In some embodiments, a tag may be determined to be in the SUSPENSION_B state if the tag is included in the SUSPENSION_B tag table. If the tag is in the SUSPENSION_B state, then processing may flow to decision block 518; otherwise, the tag may be in the SUSPENSION_A state and processing may flow to decision block 520.
At block 520, the tag may remain in the SUSPENSION A state. In at least one embodiment, a tag in the SUSPENSION A state may be blocked and may not be enabled to be deployed. In some embodiments, a tag may stay in the SUSPENSION A state for a predetermined period of time, independent of latent and/or non-latent events. After block 520, process 500 may return to a calling process to perform other actions.
If, at decision block 516, it is determined that the tag is in the SUSPENSION B state, then processing may flow from decision block 516 to decision block 518. At decision block 518, a determination may be made whether a latent event threshold is exceeded. In at least one embodiment, decision block 518 may employ embodiments of decision block 504 to determine if the latent event threshold is exceeded. In some embodiments, the latent event threshold for the SUSPENSION B state may be the same or different than the latent event threshold for the NORMAL state and/or the FLAGGED state. In one non-limiting, non-exhaustive example, the threshold number of latent events for the SUSPENSION_B state may be three consecutive latent events. However, embodiments are not so limited and other latent event thresholds may be employed. If the latent event threshold is exceeded, then processing may flow to block 524; otherwise, processing may flow to block 522.
At block 524, the tag may be moved to the SUSPENSION_A state. In at least one embodiment, moving the tag to the SUSPENSION A state may include adding the tag to the SUSPENSION A tag table and removing the tag from the FLAGGED tag table or the SUSPENSION B tag table. In some embodiments, a tag in the SUSPENSION A state may be blocked and may not be enabled to be deployed. After block 524, process 500 may return to a calling process to perform other actions.
If, at decision block 518, it is determined that the latent event threshold is not exceeded, then processing may flow from decision block 518 to block 522. At block 522, the tag may remain in the SUSPENSION_B state. In some embodiments, a tag in the SUSPENSION B state may be blocked and may not be enabled to be deployed. After block 522, process 500 may return to a calling process to perform other actions.
FIG. 6 illustrates a logical flow diagram generally showing one embodiment of a process for changing a tag state based on a non-latent event of the tag and a current state of the tag. In some embodiments, process 600 of FIG. 6 may be implemented by and/or executed on a single network device, such as network device 300 of FIG. 3. In other embodiments, process 600 or portions of process 600 of FIG. 6 may be implemented by and/or executed on a plurality of network devices, such as network device 300 of FIG. 3.
Process 600 begins, after a start block, at decision block 602, where a determination may be made whether the tag is in the NORMAL state. In at least one embodiment, decision block 602 may employ embodiments of decision block 502 of FIG. 5 to determine if the tag is in the NORMAL state. If the tag is in the NORMAL state, then processing may flow to block 604; otherwise, processing may flow to decision block 606.
At block 604, the tag may remain in the NORMAL state and the tag allowed to be deployed. In at least one embodiment, block 604 may employ embodiments of block 508 of FIG. 5. After block 604, process 600 may return to a calling process to perform other actions.
If, at decision block 602, it is determined that the tag is not in the NORMAL state, then processing may flow from decision block 602 to decision block 606. At decision block 606, a determination may be made whether the tag is in the FLAGGED state. In at least one embodiment, decision block 606 may employ embodiments of decision block 510 of FIG. 5 to determine if the tag is in the FLAGGED state. If the tag is in the FLAGGED state, then processing may flow to decision block 608; otherwise, processing may flow to decision block 610.
At decision block 608, a determination may be made whether a non-latent event threshold is exceeded. In some embodiments, the non-latent event threshold may be a total number of consecutive non-latent events. In one non-limiting, non-exhaustive example, the non-latent event threshold for the FLAGGED state may be three consecutive non-latent events. In at least one such embodiment, determining if the non-latent event threshold is exceeded may include comparing a number of consecutive non-latent events to the non-latent event threshold. In other embodiments, the non-latent event threshold may be a total number of non-latent events that occurred within a given time period. However, embodiments are not so limited and other non-latent event thresholds may be employed. If the non-latent event threshold is exceeded, then processing may flow to block 616; otherwise, processing may flow to block 614.
At block 616, the tag may be moved to the NORMAL state. In at least one embodiment, moving the tag to the NORMAL state may include removing the tag from the FLAGGED tag table and adding the tag to the NORMAL tag table. However, embodiments are not so limited and other methods of identifying and changing the tag state may be employed. In some embodiments, a tag in the NORMAL state may not be blocked and may be enabled to be deployed. In some other embodiments, a tag may return to the NORMAL state if a user resets the tag state, a tag's HTML field is edited, monitoring of the tag is disabled, and/or a geographical region to monitor the tag is changed (i.e., a user may select a geographical location of servers to monitor tags). After block 616, process 600 may return to a calling process to perform other actions.
If, at decision block 608, it is determined that the non-latent event threshold is not exceeded, then processing may flow from decision block 608 to block 614. At block 614, the tag may remain in the FLAGGED state. In at least one embodiment, block 614 may employ embodiments of block 514 of FIG. 5. After block 614, process 600 may return to a calling process to perform other actions.
If, at decision block 606, it is determined that the tag is not in the FLAGGED state, then processing may flow from decision block 606 to decision block 610. At decision block 610, a determination may be made whether the tag is in the SUSPENSION B state. In at least one embodiment, decision block 610 may employ embodiments of decision block 516 of FIG. 5 to determine if the tag is in the SUSPENSION_B state. If the tag is in the SUSPENSION_B state, then processing may flow to decision block 618; otherwise, processing may flow to decision block 612.
At block 612, the tag may remain in the SUSPENSION_A state. In at least one embodiment, block 612 may employ embodiments of block 520 of FIG. 5. After block 612, process 600 may return to a calling process to perform other actions.
If, at decision block 610, it is determined that the tag is not in the SUSPENSION B state, then processing may flow from decision block 610 to decision block 618. At decision block 618, a determination may be made whether a non-latent event threshold is exceeded. In at least one embodiment, decision block 618 may employ embodiments of decision block 608 to determine if the non-latent event threshold is exceeded. In some embodiments, the non-latent event threshold for the SUSPENSION A state may be the same or different than the non-latent event threshold for the FLAGGED state. In one non-limiting, non-exhaustive example, the threshold number of NON-latent events for the SUSPENSION_A state may be three consecutive non-latent events. However, embodiments are not so limited and other non-latent event thresholds may be employed. If the non-latent event threshold is exceeded, then processing may flow to block 622; otherwise, processing may flow to block 620.
At block 622, the tag may be moved to the FLAGGED state. In at least one embodiment, block 622 may employ embodiments of block 506 of FIG. 5. After block 622, process 600 may return to a calling process to perform other actions.
If, at decision block 618, it is determined that the non-latent event threshold is not exceeded, then processing may flow from decision block 618 to block 620. At block 620, the tag may remain in the SUSPENSION B state. In at least one embodiment, block 620 may employ embodiments of block 522 of FIG. 5. After block 620, process 600 may return to a calling process to perform other actions.
FIG. 7 illustrates a logical flow diagram generally showing one embodiment of a process for employing a tag in one of a plurality of states and changing the tag state based on latent or non-latent event. In some embodiments, process 700 of FIG. 7 may be implemented by and/or executed on a single network device, such as network device 300 of FIG. 3. In other embodiments, process 700 or portions of process 700 of FIG. 7 may be implemented by and/or executed on a plurality of network devices, such as network device 300 of FIG. 3.
Process 700 begins, after a start block, at block 702, where a tag may be employed in a NORMAL state. In at least one embodiment, a tag in the NORMAL state may not be blocked and may be enabled to be deployed. As described above (at block 404), a latency of the tag may be asynchronously monitored. In at least one embodiment, the tag latency of a tag in the NORMAL state may be monitored every 15 minutes. However, other frequencies for monitoring tags in the flagged state may be employed.
Process 700 continues at decision block 704, where a determination may be made whether a latent event for the tag has occurred. In at least one embodiment, decision block 704 may employ embodiments of decision block 406 of FIG. 4 to determine if a latent event has occurred based on the asynchronously monitored tag latency. If a latent event has occurred, then processing may flow to decision block 705; otherwise, processing may loop to block 702, where the tag may remain in the NORMAL state.
At decision block 705, a determination may be made whether a latent event threshold is exceeded. In at least one embodiment, decision block 705 may employ embodiments of decision block 504 of FIG. 5 to determine if a latent event threshold is exceeded for the tag in the NORMAL state. If the latent event threshold is exceeded, then the tag may be moved to the FLAGGED state and processing may flow to block 706; otherwise, processing may loop to block 702, where the tag may remain in the NORMAL state. In some embodiments, process 700 may employ embodiments of block 506 of FIG. 5 to move a tag to the FLAGGED state.
At block 706, the tag may be employed in the FLAGGED state. In at least one embodiment, a tag in the FLAGGED state may not be blocked and may be enabled to be deployed. In at least one embodiment, the tag latency of a tag in the FLAGGED state may be monitored every five minutes. However, other frequencies for monitoring tags in the FLAGGED state may be employed.
In some embodiments, a user may manually move a tag in the FLAGGED state to the NORMAL by “resetting” the tag. In at least one embodiment, a user may move a tag to the NORMAL state by clicking on a “reset” button. However, embodiments are not so limited and other embodiments for resetting a tag and/or manually moving a tag to the NORMAL state may be employed. In at least one embodiment, manually moving a tag may occur independent of the process for monitoring the tag's latency. If the tag in the FLAGGED state is manually “reset” to the NORMAL state, then process 700 may loop (not shown) to block 702. In at least one embodiment, a tag in any state (and/or predetermined states) may be “reset” to the NORMAL state.
In any event, process 700 continues at decision block 710, where a determination may be made whether a latent event for the tag has occurred. In at least one embodiment, decision block 710 may employ embodiments of decision block 704 to determine if a latent event has occurred. If a latent event has occurred, then processing may flow to decision block 712; otherwise, processing may flow to decision block 708.
At decision block 708, a determination may be made whether a non-latent event threshold is exceeded. In at least one embodiment, decision block 708 may employ embodiments of decision block 608 of FIG. 6 to determine if a non-latent event threshold is exceeded for the tag in the FLAGGED state. If the non-latent event threshold is exceeded, then the tag may be moved to the NORMAL state and processing may flow to block 702; otherwise, processing may loop to block 706, where the tag may remain in the FLAGGED state. In some embodiments, process 700 may employ embodiments of block 616 of FIG. 6 to move a tag to the NORMAL state.
If, at decision block 710, a latent event has occurred, then processing may flow from decision block 710 to decision block 712. At decision block 712, a determination may be made whether a latent event threshold is exceeded. In at least one embodiment, decision block 712 may employ embodiments of decision block 512 of FIG. 5 to determine if a latent event threshold is exceeded for the tag in the FLAGGED state. If the latent event threshold is exceeded, then the tag may be moved to the SUSPENSION_A state and processing may flow to block 714; otherwise, processing may loop to block 706, where the tag may remain in the FLAGGED state. In some embodiments, process 700 may employ embodiments of block 524 of FIG. 5 to move a tag to the SUSPENSION_A state.
At block 714, the tag may be employed in the SUSPENSION_A state. In some embodiments, a tag in the SUSPENSION_A state may remain in the SUSPENSION_A state for a predetermined period of time. In at least one embodiment, the tag latency may not be monitored while the tag is in the SUSPENSION A state. In some embodiments, a tag in the SUSPENSION A state may be blocked and may not be enabled to be deployed.
In some embodiments, a user may manually move a tag in the SUSPENSION A state to the NORMAL by “resetting” the tag. In at least one embodiment, block 714 may employ embodiments of block 706 to “reset” a tag. If the tag in the SUSPENSION A state is manually “reset” to the NORMAL state, then process 700 may loop (not shown) to block 702.
Process 700 continues at decision block 716, where a determination may be made whether the time period for the tag to remain in the SUSPENSION A state has elapsed. In at least one embodiment, the time period may be determined and/or modified by a user. In some embodiments, the time period may be 20 minutes. However, embodiments are not so limited and other time periods may be employed. If the time period has elapsed, then the tag may be moved to a SUSPENSION B state and processing may flow to block 718; otherwise, processing may loop to block 714, where the tag may remain in the SUSPENSION_A state.
At block 718, the tag may be employed in the SUSPENSION_B state. In at least one embodiment, a tag in the SUSPENSION B state may be blocked and may not be enabled to be deployed. In at least one embodiment, the tag latency of a tag in the SUSPENSION B state may be monitored every one minute. However, other frequencies for monitoring tags in the SUSPENSION B state may be employed.
In some embodiments, a user may manually move a tag in the SUSPENSION B state to the NORMAL by “resetting” the tag. In at least one embodiment, block 718 may employ embodiments of block 706 to “reset” a tag. If the tag in the SUSPENSION B state is manually “reset” to the NORMAL state, then process 700 may loop (not shown) to block 702.
Process 700 next proceeds to decision block 720, where a determination may be made whether a latent event for the tag has occurred. In at least one embodiment, decision block 720 may employ embodiments of decision block 704 to determine if a latent event has occurred. If a latent event has occurred, then processing may flow to decision block 722; otherwise, processing may flow to decision block 724.
At decision block 722, a determination may be made whether a latent event threshold is exceeded. In at least one embodiment, decision block 722 may employ embodiments of decision block 518 of FIG. 5 to determine if a latent event threshold is exceeded for the tag in the SUSPENSION B state. If the latent event threshold is exceeded, then the tag may be moved to the SUSPENSION_A state and processing may flow to block 714; otherwise, processing may loop to block 718, where the tag may remain in the SUSPENSION B state. In some embodiments, process 700 may employ embodiments of block 524 of FIG. 5 to move a tag to the SUSPENSION A state.
If, at decision block 720, a latent event has not occurred, then processing may flow from decision block 720 to decision block 724. At decision block 724, a determination may be made whether a non-latent event threshold is exceeded. In at least one embodiment, decision block 724 may employ embodiments of decision block 618 of FIG. 6 to determine if a non-latent event threshold is exceeded for the tag in the SUSPENSION B state. If the non-latent event threshold is exceeded, then the tag may be moved to the FLAGGED state and processing may loop to block 706; otherwise, processing may loop to block 718, where the tag may remain in the SUSPENSION B state. In some embodiments, process 700 may employ embodiments of block 506 of FIG. 5 to move a tag to the FLAGGED state.
It will be understood that each block of the flowchart illustration, and combinations of blocks in the flowchart illustration, can be implemented by computer program instructions. These program instructions may be provided to a processor to produce a machine, such that the instructions, which execute on the processor, create means for implementing the actions specified in the flowchart block or blocks. The computer program instructions may be executed by a processor to cause a series of operational steps to be performed by the processor to produce a computer-implemented process such that the instructions, which execute on the processor to provide steps for implementing the actions specified in the flowchart block or blocks. The computer program instructions may also cause at least some of the operational steps shown in the blocks of the flowchart to be performed in parallel. Moreover, some of the steps may also be performed across more than one processor, such as might arise in a multiprocessor computer system. In addition, one or more blocks or combinations of blocks in the flowchart illustration may also be performed concurrently with other blocks or combinations of blocks, or even in a different sequence than illustrated without departing from the scope or spirit of the invention.
Accordingly, blocks of the flowchart illustration support combinations of means for performing the specified actions, combinations of steps for performing the specified actions and program instruction means for performing the specified actions. It will also be understood that each block of the flowchart illustration, and combinations of blocks in the flowchart illustration, can be implemented by special purpose hardware-based systems, which perform the specified actions or steps, or combinations of special purpose hardware and computer instructions. The foregoing example should not be construed as limiting and/or exhaustive, but rather, an illustrative use case to show an implementation of at least one of the various embodiments of the invention.
FIG. 8 shows one embodiment of a use case illustrating graphical representation of a plurality of tag states and events that may trigger a state change. As shown, tags may be in one of five states of system 800: NORMAL state 802, FLAGGED state 804, SUSPENSION_A state 806, or SUSPENSION_B state 808. In some embodiments, tag in NORMAL state 802, FLAGGED state 806, SUSPENSION A state 806, and/or SUSPENSION B state 808 may be employed similar to embodiments of block 702, block 706, block 714, and/or block 718 of FIG. 7, respectively.
A tag in NORMAL state 802 may be allowed to be fired. In at least one embodiment, allowing a tag to fire may include determining the tag is available to be deployed and enabling the tag to be deployed. In some embodiments, a tag in NORMAL state 802 may be moved to FLAGGED state 804 if one latent event is monitored for the tag. However, embodiments are not so limited; but rather, other metrics may be employed to determine if a tag is moved from NORMAL state 802, which is described in more detail below.
A tag in FLAGGED state 804 may be allowed to be fired. In some embodiments, a tag in FLAGGED state 804 may be moved to SUSPENSION A state 806 if three consecutive latent events are monitored for the tag. In other embodiments, a tag in FLAGGED state 804 may be moved to NORMAL state 802 if three consecutive non-latent events are monitored for the tag. However, embodiments are not so limited; but rather, other metrics may be employed to determine if a tag is moved from FLAGGED state 804, which is described in more detail below.
A tag in SUSPENSION A state 806 may be blocked from firing. In at least one embodiment, blocking a tag from firing include determining the tag is unavailable to be deployed and not enabling the tag to be deployed. In some embodiments, a tag in SUSPENSION_A state 806 may be moved to SUSPENSION_B state 808 after remaining in the SUSPENSION A state for 20 minutes. However, embodiments are not so limited; but rather, other metrics may be employed to determine if a tag is moved from SUSPENSION A state 806, which is described in more detail below.
A tag in SUSPENSION B state 808 may be blocked from firing. In some embodiments, a tag in SUSPENSION_B state 808 may be moved to SUSPENSION_A state 806 if three consecutive latent events are monitored for the tag. In other embodiments, a tag in SUSPENSION B state 808 may be moved to FLAGGED state 804 if three consecutive non-latent events are monitored for the tag. However, embodiments are not so limited; but rather, other metrics may be employed to determine if a tag is moved from SUSPENSION B state 808.
It should be noted that FIG. 8 shows one embodiment of a plurality of states and the movement of a tag from one state to another state. However, embodiments are not so limited. For example, in some embodiments, a different number of states may be employed. In other embodiments, a tag may move from one state to another state, which may not be illustrated in FIG. 8, such as, for example, a tag may change from NORMAL state 802 to SUSPENSION A state 806. In yet other embodiments, each state may employ different metrics to determine if a tag is moved from a given state and which state the tag is moved to. In some embodiments, these metrics may be predetermined, configurable, and/or modifiable for each user. Different embodiments of metrics that may be employed may include, but are not limited to, a number of consecutive latent events, a number of latent events within a predetermined time period, a severity of a latent event (e.g., a tag latency value above a severity threshold value), a number of consecutive latent events above the severity threshold, a number of latent events above the severity threshold within a predetermined time period, a number of consecutive non-latent events, a number of non-latent events within a predetermined time period, a mildness of one or more non-latent events (e.g., a tag latency value below a mildness threshold value), a number of consecutive non-latent events below the mildness threshold, a number of non-latent events below the mildness threshold within a predetermined time period, a time duration a tag is in a given state, or the like, or any combination thereof.
Alternative Embodiment
FIGS. 9A-9B illustrate a logical flow diagram generally showing an alternative embodiment of a process for employing a tag in one of a plurality of states and changing the tag state based on tag latency. In some embodiments, process 900 of FIGS. 9A-9B may be implemented by and/or executed on a single network device, such as network device 300 of FIG. 3. In other embodiments, process 900 or portions of process 900 of FIGS. 9A-9B may be implemented by and/or executed on a plurality of network devices, such as network device 300 of FIG. 3.
Process 900 begins, after a start block, at block 902, where a tag may be employed in a NORMAL state. In at least one embodiment, block 902 may employ embodiments of block 702 of FIG. 7 to employ the tag in a NORMAL state. In some embodiments, a tag in the NORMAL state may have a monitoring frequency of 15 minutes.
Process 900 proceeds to decision block 904, where a determination may be made whether a monitored tag latency of a tag exceeded a suspend threshold. In at least one embodiment, the suspend threshold may be a predetermined tag latency (i.e., a predetermined amount of time). In at least one embodiment, the suspend threshold may be determined and/or modified by a user. If the tag latency exceeds the suspend threshold, then the tag may be moved to a PRE-SUSPENSION state and processing may flow to block 912; otherwise, processing may flow to decision block 906.
At decision block 906, a determination may be made whether the tag latency a tag exceeds a warning threshold. In at least one embodiment, the warning threshold may be a predetermined tag latency. In at least one embodiment, the warning threshold may be determined and/or modified by a user. In some embodiments, the warning threshold may be greater than a user desired tag latency, but less than the suspend threshold. If the tag latency exceeds the warning threshold (but does not exceed the suspend threshold), then the tag may be moved to a FLAGGED state and processing may flow to block 908; otherwise, processing may loop to block 902, where the tag may remain in the NORMAL state.
At block 908, the tag may be employed in the FLAGGED state. In at least one embodiment, block 908 may employ embodiments of block 706 of FIG. 7 to employ the tag in a FLAGGED state. In some embodiments, a tag in the FLAGGED state may have a monitor frequency of five minutes. In at least one embodiment, tags in the FLAGGED state may remain in the FLAGGED state until the tag latency exceeds a suspend threshold (such as at decision block 910) or does not exceed a warning threshold (such as at decision block 914). In some embodiments, an email, text message, or other notification may be sent to a users indicating that a tag is in the FLAGGED state.
Process 900 continues at decision block 910, where a determination may be made whether the tag latency of a tag exceeds a suspend threshold. In at least one embodiment, decision block 910 may employ embodiments of decision block 904 to determine if the suspend threshold is exceeded. If the tag latency exceeds the suspend threshold, then the tag may be moved to a PRE-SUSPENDED state and processing may flow to block 912; otherwise, processing may flow to decision block 914.
At decision block 914, a determination may be made whether the tag latency of a tag exceeds a warning threshold. In at least one embodiment, decision block 910 may employ embodiments of decision block 904 to determine if the warning threshold is exceeded. If the tag latency exceeds the warning threshold (but does not exceed the suspend threshold), then the tag may remain in the FLAGGED state and processing may loop to block 908; otherwise, the tag may be moved to the NORMAL state and processing may loop to block 902.
If, at decision block 910, the tag latency exceeds the suspend threshold, then processing may flow from decision block 910 to block 912. At block 912, the tag may be employed in a PRE-SUSPENDED state. In at least one embodiment, the tag may not be blocked and may be enabled to be deployed. In some embodiments, a tag in the PRE-SUSPENDED state may have a monitor frequency of one minute. In at least one embodiment, tags in the PRE-SUSPENDED state may remain in the PRE-SUSPENDED state for a time period of five minutes.
Process 900 next proceeds to decision block 916, where a determination may be made whether the tag latency of a tag exceeds a suspend threshold. In at least one embodiment, decision block 916 may employ embodiments of decision block 904 to determine if the suspend threshold is exceeded. If the tag latency exceeds the suspend threshold, then processing may flow to decision block 918; otherwise, the tag may be moved to the FLAGGED state and processing may loop to block 908.
At decision block 918, a determination may be made whether a consecutive number of suspend thresholds is exceeded. In at least one embodiment the consecutive suspend threshold may be two consecutive monitored tag latencies that exceed the suspend threshold. If the consecutive suspend threshold is exceeded, then the tag may be moved to a SUSPENDED state and processing may flow to block 920 of FIG. 9B; otherwise, processing may loop to block 912, where the tag may remain in the PRE-SUSPENDED state.
Process 900 continues at block 920 of FIG. 9B, where the tag may be employed in a SUSPENDED state. In at least one embodiment, the tag may be blocked and may not be enabled to be deployed. In some embodiments, a tag in the SUSPENDED state may not be monitored. In at least one embodiment, tags in the SUSPENDED state may remain in the SUSPENDED state for a time period of 30 minutes. In some embodiments, an email, text message, or other notification may be sent to a users indicating that a tag is in the FLAGGED state.
Process 900 next proceeds to decision block 922, where a determination may be made whether a suspended state limit is exceeded. In at least one embodiment, the suspended state limit may be 30 minutes. If the suspended state limit is exceeded, then the tag may be moved to a POST-SUSPENDED state and processing may flow to block 924; otherwise, processing may loop to block 920, where the tag may remain in the SUSPENDED state.
At block 924, the tag may be employed in a POST-SUSPENDED state. In at least one embodiment, the tag may be blocked and may not be enabled to be deployed. In some embodiments, a tag in the POST-SUSPENDED state may have a monitor frequency of five minutes. In at least one embodiment, tags in the POST-SUSPENDED state may remain in the POST-SUSPENDED state for a time period of five minutes.
Process 900 continues at decision block 926, where a determination may be made whether the tag latency of a tag exceeds a suspend threshold. In at least one embodiment, decision block 926 may employ embodiments of decision block 904 to determine if the suspend threshold is exceeded. If the tag latency exceeds the suspend threshold, then processing may flow to decision block 928; otherwise, processing may flow to decision block 930.
At decision block 928, a determination may be made whether a consecutive number of suspend thresholds is exceeded. In at least one embodiment, decision block 928 may employ embodiments of decision block 918 of FIG. 9A to determine if the consecutive suspend threshold is exceeded. In at least one embodiment the consecutive suspend threshold may be two consecutive monitored tag latencies that exceed the suspend threshold. If the consecutive suspend threshold is exceeded, then the tag may be moved to a SUSPENDED state and processing may loop to block 920; otherwise, processing may loop to block 924, where the tag may remain in the POST-SUSPENDED state.
If, at decision block 926, the tag latency does not exceed the suspend threshold, then processing may flow from decision block 926 to decision block 930. At decision block 930, a determination may be made whether the tag latency of a tag exceeds a warning threshold. In at least one embodiment, decision block 930 may employ embodiments of decision block 904 to determine if the warning threshold is exceeded. If the tag latency exceeds the warning threshold (but does not exceed the suspend threshold), then processing may flow to decision block 932; otherwise, the tag may be moved to the normal state and processing may loop to block 902 of FIG. 9A.
At decision block 932, a determination may be made whether a consecutive number of warning thresholds is exceeded. In at least one embodiment the consecutive warning threshold may be two consecutive monitored tag latencies that exceed the warning threshold. If the consecutive warning threshold is exceeded, then the tag may be moved to the FLAGGED state and processing may loop to block 922 of FIG. 9A; otherwise, processing may loop to block 924, where the tag may remain in the POST-SUSPENDED state.
FIG. 10 shows an alternative embodiment of a use case illustrating graphical representation of a plurality of tag states and events that may trigger a state change. As shown, tags may be in one of five states of system 1000: NORMAL state 1002, FLAGGED state 1004, PRE-SUSPENDED state 1006, SUSPENDED state 1008, or POST-SUSPENDED state 1010. In some embodiments, tag in NORMAL state 1002, FLAGGED state 1004, PRE-SUSPENDED state 1006, SUSPENDED state 1008, and/or POST-SUSPENDED state 1010 may be employed similar to embodiments of block 902, block 908, block 912, block 920, and/or block 924 of FIG. 9, respectively.
Step 1: tags in NORMAL state 1002 that exceed a specified warning threshold may be moved to FLAGGED state 1004. Tags in FLAGGED state 1004 may return to NORMAL state 1002 if latency numbers subside (i.e. a monitored tag latency is less than the warning threshold).
Step 2: tags in NORMAL state 1002 that exceed a specified suspend threshold may be moved to PRE-SUSPENDED state 1006. In at least one embodiment, the suspend threshold may be greater than the warning threshold. In one non-limiting, non-exhaustive example, the warning threshold may be 500 milliseconds and the suspend threshold may be 800 milliseconds.
Step 3: tags in FLAGGED state 1004 that exceed the suspend threshold may be moved to PRE-SUSPENDED state 1006. Tags in PRE-SUSPENDED state 1006 may return to FLAGGED state 1004 if latency numbers subside (i.e. a monitored tag latency is less than the suspend threshold).
Step 4: tags in PRE-SUSPENDED state 1006 that exceed the suspend threshold for two consecutive attempts may be moved to SUSPENDED state 1008.
Step 5: tags in SUSPENDED state 1008 that have reached their suspended state limit (e.g., 30 minutes may be moved to POST-SUSPENDED state 1010. Tags in POST-SUSPENDED state 1010 may return to SUSPENDED state 1008 if they exceed the suspend threshold for two consecutive attempts. In some embodiments, the suspend threshold employed to determine when to move tags from one state to another state may be the same or different threshold values.
Step 6: tags in POST-SUSPENDED state 1010 can move to FLAGGED state 1004 if they exceed the warning threshold for two consecutive attempts. Tags in the POST-SUSPENDED state 1010 can move to NORMAL state 1002 if they do not exceed the warning threshold or the suspend threshold for two consecutive attempts.
Use Case Operating Environment
FIG. 11 shows one embodiment of a use case illustrating a system diagram of a system that may be utilized to monitor tag latency and control tag state changes and deployment. As shown, system 1100 may include a plurality of monitor servers, a control server, a database, and tag servers. In some embodiments, the plurality of monitor servers may be similar to embodiments of TMSD 112 of FIG. 1. The plurality of monitor servers may include multiple groups of monitor servers to monitor tags in different states, including: monitor servers post-suspended tags, monitor servers suspended tags, monitor servers pre-suspended tags, monitor servers flagged tags, and monitor servers normal tags. Each of the groups of monitor servers may be physically located at different geographic locations, such as North America (NA), Europe (EU), Asia (i.e., Asia and Pacific (APAC)), and South America (SA). In some embodiments, a user may be enabled to select which geographic location of monitor servers may monitor tags.
A database may contain a list of all tags (i.e. all tags table). The database may also include a plurality of tables for each of a plurality of tag states, including: suspended tag table, pre-suspended tag table, post-suspended tag table, normal tag table, and flagged tag table.
A control server may access the database to determine which tags to monitor and when. In some embodiments, the control server may be similar to embodiments of TCSD 114 of FIG. 1. When a tag is to be monitored, the control server may notify (e.g., send a tag identifier) the monitor servers in the selected geographic location for the current state of the tag. For example, if a user selects Europe monitor servers and a tag in the FLAGGED state is to be monitored, then the control server may notify the monitor servers flagged tags in Europe. Each of the plurality of monitor servers may provide a tag latency of monitored tags to the control server. Based on the tag latency, the control server may determine whether or not to change a tag's state. If the tag state changes, the control server may modify the appropriate tables in the database to reflect the changed state. In some embodiments, the control server may send an email or other notification to a user if a tag changes to a specific state (e.g., flagged, suspended, or the like). Additionally, the control server may communicate with a push service to identify tags that are available for deployment (i.e., enable a tag for deployment).
The push service may be configured to provide tags to the tag servers. In at least one embodiment, the push service may provide the tag servers with the most up-to-date information on available tags received from the control server. Based on the information provided by the push service, the tag servers may deploy tags in a web page of the client browser. In some embodiments, the tag servers may be similar to embodiments of TDSD 116 of FIG. 1. In at least one embodiment, the control server and the monitoring servers may execute asynchronously to web page requests (including the push service and the tag servers).
In some embodiments, if a tag is blocked from deployment (e.g., in SUSPENSION A state 806 and/or SUSPENSION B state 808 of FIG. 8 or SUSPENDED state 1008 and/or POST-SUSPENDED state 1010 of FIG. 10), the control server may enable an “inert” tag for deployment instead of the blocked tag. In at least one embodiment, an inert tag may be a non-executable version of the blocked tag. In some embodiments, the inert tag may be utilized to determine a number of times the blocked tag might have been deployed, but was not (because it was blocked). In at least one embodiment, the control server may provide the inert tag to the push service and ultimately to the tag servers. In some embodiments, the tag servers may treat the inert tag as a real tag for gathering statistical information about tags, but may not deploy the inert tag.
The above specification, examples, and data provide a complete description of the composition, manufacture, and use of the invention. Since many embodiments of the invention can be made without departing from the spirit and scope of the invention, the invention resides in the claims hereinafter appended.

## Claims

1. A method for managing web pages over a network, comprising:
monitoring latency of code to be injected during presentation of a web page, wherein the monitoring is asynchronous to requests for the web page and the monitoring corresponds to a current state for the code that is to be injected during presentation of the web page;
updating a state for the code using a latency and the current state; and
determining a deployability of the code using the state of the code in response to a request for the web page.

2. The method of claim 1, wherein the code corresponds to a plurality of states that includes at least a normal state, a flagged state, and at least one suspension state.

3. The method of claim 1, wherein determining the deployability of the code further comprises:
enabling deployment if the code is in a normal state or a flagged state; and
blocking deployment if the code is in a suspension state.

4. The method of claim 1, wherein updating the state further comprises:
moving from a first state to a second state if the latency results in at least one of the following, including:
a threshold number of consecutive latent events is exceeded;
a threshold number of latent events within a given time period is exceeded; or
the latency exceed a severity threshold value.

5. The method of claim 1, wherein updating the state further comprises:
moving from a first state to a second state if the latency results in at least one of the following, including:
a threshold number of consecutive non-latent events is exceeded;
a threshold number of non-latent events within a given time period is exceeded; or
the latency is below a mildness threshold value.

6. The method of claim 1, wherein updating the state further comprises:
if the latency results in a latent event, performing further actions, including:
if the code is in a normal state, moving the code to a flagged state if a threshold number of latent events is exceeded;
if the code is in the flagged state, moving the code to a first suspension state if another threshold number of latent events is exceeded;
if the code is in the first suspension state, moving the code to a second suspension state after a predetermined time period; and
if the code is in the second suspension state, moving the code to the first suspension state if yet another threshold number of latent events is exceeded.

7. The method of claim 1, wherein updating the state further comprises:
if the latency results in a non-latent event, performing further actions, including:
if the code is in a flagged state, moving the code to a normal state if a threshold number of non-latent events is exceeded; and
if the code is in a suspension state, moving the code to the flagged state if another threshold number of non-latent events is exceeded.

8. The method of claim 1, wherein updating the state further comprises:
if the code is in a normal state, moving the code to a flagged state if the latency exceeds a warning threshold;
if the code is in the normal state, moving the code to a pre-suspended state if the latency exceeds a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in the flagged state, moving the code to the pre-suspended state if the latency exceeds the suspend threshold;
if the code is in the pre-suspended state, moving the code to a suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts;
if the code is in the suspended state, moving the code to a post-suspended state after a predetermined time period; and
if the code is in the post-suspended state, moving the code to the suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts.

9. The method of claim 1, wherein updating the state further comprises:
if the code is in a flagged state, moving the code to a normal state if the latency is less than a warning threshold;
if the code is in a pre-suspended state, moving the code to the flagged state if the latency is less than a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in a post-suspended state, moving the code to the flagged state if the latency exceeds the warning threshold and is less than the suspend threshold for multiple consecutive monitoring attempts; and
if the code is in the post-suspended state, moving the code to the normal state if the latency is less than the warning threshold for multiple consecutive monitoring attempts.

10. A system for managing web pages over a network, comprising:
at least one monitoring server device that is configured to perform actions, including:
monitoring latency of code to be injected during presentation of a web page, wherein the monitoring is asynchronous to requests for the web page and the monitoring corresponds to the current state for the code that is to be injected during presentation of the web page;
updating a state for the code using a latency and the current state; and
determining a deployability of the code using the state of the code in response to a request for the web page.

11. The system of claim 10, wherein the at least one monitoring server device determines the deployability of the code by enabling deployment of the code if the code is in a normal state or a flagged state and blocking deployment of the code if code is in a suspension state.

12. The system of claim 10, wherein the at least one monitoring server device updates the state by moving the code from a first state to a second state if the latency results in at least one of the following, including:
a threshold number of consecutive latent events is exceeded;
a threshold number of latent events within a given time period is exceeded; or
the latency exceed a severity threshold value.

13. The system of claim 10, wherein the at least one monitoring server device updates the state of the code by moving the code from a first state to a second state if the latency results in at least one of the following, including:
a threshold number of consecutive non-latent events is exceeded;
a threshold number of non-latent events within a given time period is exceeded; or
the latency is below a mildness threshold value.

14. The system of claim 10, wherein the at least one monitoring server device updates the state if the latency results in a latent event, by:
if the code is in a normal state, moving the code to a flagged state if a threshold number of latent events is exceeded;
if the code is in the flagged state, moving the code to a first suspension state if another threshold number of latent events is exceeded;
if the code is in the first suspension state, moving the code to a second suspension state after a predetermined time period; and
if the code is in the second suspension state, moving the code to the first suspension state if yet another threshold number of latent events is exceeded.

15. The system of claim 10, wherein the at least one monitoring server device updates the state if the latency results in a non-latent event, by:
if the code is in a flagged state, moving the code to a normal state if a threshold number of non-latent events is exceeded; and
if the code is in a suspension state, moving the code to the flagged state if another threshold number of non-latent events is exceeded.

16. The system of claim 10, wherein the at least one monitoring server device updates the state of the code, by:
if the code is in a normal state, moving the code to a flagged state if the latency exceeds a warning threshold;
if the code is in the normal state, moving the code to a pre-suspended state if the latency exceeds a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in the flagged state, moving the code to the pre-suspended state if the latency exceeds the suspend threshold;
if the code is in the pre-suspended state, moving the code to a suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts;
if the code is in the suspended state, moving the code to a post-suspended state after a predetermined time period; and if the code is in the post-suspended state, moving the code to the suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts.

17. The system of claim 10, wherein the at least one monitoring server device updates the state of the code by:
if the code is in a flagged state, moving the code to a normal state if the latency is less than a warning threshold;
if the code is in a pre-suspended state, moving the code to the flagged state if the latency is less than a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in a post-suspended state, moving the code to the flagged state if the latency exceeds the warning threshold and is less than the suspend threshold for multiple consecutive monitoring attempts; and
if the code is in the post-suspended state, moving the code to the normal state if the latency is less than the warning threshold for multiple consecutive monitoring attempts.

18. A processor readable non-transitory storage media that includes instructions for managing web pages over a network, wherein the execution of the instructions by a processor enables actions, comprising:
monitoring latency of code to be injected during presentation of a web page, wherein the monitoring is asynchronous to requests for the web page and the monitoring corresponds to a current state for the code that is to be injected during presentation of the web page;
updating a state for the code using a latency and the current state; and
determining a deployability of the code using the state of the code in response to a request for the web page.

19. The processor readable non-transitory storage media of claim 18, wherein the code corresponds to a plurality of states that includes at least a normal state, a flagged state, and at least one suspension state.

20. The processor readable non-transitory storage media of claim 18, wherein the execution of the instructions by the processor further implements determining the deployability of the code by: enabling deployment if the code is in a normal state or a flagged state; and blocking deployment if the code is in a suspension state.

21. The processor readable non-transitory storage media of claim 18, wherein the execution of the instructions by the processor further implements updating the state by:
moving from a first state to a second state if the latency results in at least one of the following, including:
a threshold number of consecutive latent events is exceeded; a threshold number of latent events within a given time period is exceeded; or the latency exceed a severity threshold value.

22. The processor readable non-transitory storage media of claim 18, wherein the execution of the instructions by the processor further implements updating the state by:
moving from a first state to a second state if the latency results in at least one of the following, including: a threshold number of consecutive non-latent events is exceeded; a threshold number of non-latent events within a given time period is exceeded; or the latency is below a mildness threshold value.

23. The processor readable non-transitory storage media of claim 18, wherein the execution of the instructions by the processor further implements updating the state by:
if the latency results in a latent event, performing further actions, including:
if the code is in a normal state, moving the code to a flagged state if a threshold number of latent events is exceeded;
if the code is in the flagged state, moving the code to a first suspension state if another threshold number of latent events is exceeded;
if the code is in the first suspension state, moving the code to a second suspension state after a predetermined time period; and
if the code is in the second suspension state, moving the code to the first suspension state if yet another threshold number of latent events is exceeded.

24. The processor readable non-transitory storage media of claim 18, wherein the execution of the instructions by the processor further implements updating the state by:
if the latency results in a non-latent event, performing further actions, including:
if the code is in a flagged state, moving the code to a normal state if a threshold number of non-latent events is exceeded; and if the code is in a suspension state, moving the code to the flagged state if another threshold number of non-latent events is exceeded.

25. The processor readable non-transitory storage media of claim 18, wherein the execution of the instructions by the processor further implements updating the state by:
if the code is in a normal state, moving the code to a flagged state if the latency exceeds a warning threshold;
if the code is in the normal state, moving the code to a pre-suspended state if the latency exceeds a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in the flagged state, moving the code to the pre-suspended state if the latency exceeds the suspend threshold;
if the code is in the pre-suspended state, moving the code to a suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts;
if the code is in the suspended state, moving the code to a post-suspended state after a predetermined time period; and
if the code is in the post-suspended state, moving the code to the suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts.

26. The processor readable non-transitory storage media of claim 18, wherein the execution of the instructions by the processor further implements updating the state by:
if the code is in a flagged state, moving the code to a normal state if the latency is less than a warning threshold;
if the code is in a pre-suspended state, moving the code to the flagged state if the latency is less than a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in a post-suspended state, moving the code to the flagged state if the latency exceeds the warning threshold and is less than the suspend threshold for multiple consecutive monitoring attempts; and
if the code is in the post-suspended state, moving the code to the normal state if the latency is less than the warning threshold for multiple consecutive monitoring attempts.

27. A network device for managing tags for web pages, comprising:
a memory for storing at least instructions; and a processor that executes the instructions to enable actions, including monitoring latency of code to be injected during presentation of a web page, wherein the monitoring is asynchronous to requests for the web page and the monitoring corresponds to a current state for the code that is to be injected during presentation of the web page;
updating a state for the code using a latency and the current state; and
determining a deployability of the code using the state of the code in response to a request for the web page.

28. The network device of claim 27, wherein the code corresponds to a plurality of states that includes at least a normal state, a flagged state, and at least one suspension state.

29. The network device of claim 27, wherein the execution of the instructions by the processor further implements determining the deployability of the code by:
enabling deployment if the code is in a normal state or a flagged state; and
blocking deployment if the code is in a suspension state.

30. The network device of claim 27, wherein execution of the instructions by the processor further implements updating the state by:
moving from a first state to a second state if the latency results in at least one of the following, including:
a threshold number of consecutive latent events is exceeded;
a threshold number of latent events within a given time period is exceeded; or
the latency exceed a severity threshold value.

31. The network device of claim 27, wherein execution of the instructions by the processor further implements updating the state by:
moving from a first state to a second state if the latency results in at least one of the following, including:
a threshold number of consecutive non-latent events is exceeded;
a threshold number of non-latent events within a given time period is exceeded; or
the latency is below a mildness threshold value.

32. The network device of claim 27, wherein execution of the instructions by the processor further implements updating the state by:
if the latency results in a latent event, performing further actions, including:
if the code is in a normal state, moving the code to a flagged state if a threshold number of latent events is exceeded;
if the code is in the flagged state, moving the code to a first suspension state if another threshold number of latent events is exceeded;
if the code is in the first suspension state, moving the code to a second suspension state after a predetermined time period; and
if the code is in the second suspension state, moving the code to the first suspension state if yet another threshold number of latent events is exceeded.

33. The network device of claim 27, wherein execution of the instructions by the processor further implements updating the state by:
if the latency results in a non-latent event, performing further actions, including:
if the code is in a flagged state, moving the code to a normal state if a threshold number of non-latent events is exceeded; and
if the code is in a suspension state, moving the code to the flagged state if another threshold number of non-latent events is exceeded.

34. The network device of claim 27, wherein execution of the instructions by the processor further implements updating the state by:
if the code is in a normal state, moving the code to a flagged state if the latency exceeds a warning threshold; if the code is in the normal state, moving the code to a pre-suspended state if the latency exceeds a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in the flagged state, moving the code to the pre-suspended state if the latency exceeds the suspend threshold;
if the code is in the pre-suspended state, moving the code to a suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts;
if the code is in the suspended state, moving the code to a post-suspended state after a predetermined time period; and if the code is in the post-suspended state, moving the code to the suspended state if the latency exceeds the suspend threshold for multiple consecutive monitoring attempts.

35. The network device of claim 27, wherein execution of the instructions by the processor further implements updating the state by:
if the code is in a flagged state, moving the code to a normal state if the latency is less than a warning threshold;
if the code is in a pre-suspended state, moving the code to the flagged state if the latency is less than a suspend threshold, wherein the suspend threshold is greater than the warning threshold;
if the code is in a post-suspended state, moving the code to the flagged state if the latency exceeds the warning threshold and is less than the suspend threshold for multiple consecutive monitoring attempts; and
if the code is in the post-suspended state, moving the code to the normal state if the latency is less than the warning threshold for multiple consecutive monitoring attempts.